Index: uspace/lib/c/Makefile =================================================================== --- uspace/lib/c/Makefile (revision 111d2d6731b1fbc5a2181c92094ca7b8dbaf9d2f) +++ uspace/lib/c/Makefile (revision 762083bc8a2d6259a231487a7f1d20a786ff0a6b) @@ -71,4 +71,5 @@ generic/device/hw_res_parsed.c \ generic/device/char_dev.c \ + generic/device/clock_dev.c \ generic/device/graph_dev.c \ generic/device/nic.c \ Index: uspace/lib/c/generic/async.c =================================================================== --- uspace/lib/c/generic/async.c (revision 111d2d6731b1fbc5a2181c92094ca7b8dbaf9d2f) +++ uspace/lib/c/generic/async.c (revision 762083bc8a2d6259a231487a7f1d20a786ff0a6b) @@ -638,5 +638,5 @@ if (usecs) { - gettimeofday(&conn->wdata.to_event.expires, NULL); + getuptime(&conn->wdata.to_event.expires); tv_add(&conn->wdata.to_event.expires, usecs); } else @@ -967,5 +967,5 @@ { struct timeval tv; - gettimeofday(&tv, NULL); + getuptime(&tv); futex_down(&async_futex); @@ -1024,5 +1024,5 @@ struct timeval tv; - gettimeofday(&tv, NULL); + getuptime(&tv); if (tv_gteq(&tv, &waiter->to_event.expires)) { @@ -1331,5 +1331,5 @@ timeout = 0; - gettimeofday(&msg->wdata.to_event.expires, NULL); + getuptime(&msg->wdata.to_event.expires); tv_add(&msg->wdata.to_event.expires, timeout); @@ -1413,5 +1413,5 @@ msg->wdata.fid = fibril_get_id(); - gettimeofday(&msg->wdata.to_event.expires, NULL); + getuptime(&msg->wdata.to_event.expires); tv_add(&msg->wdata.to_event.expires, timeout); Index: uspace/lib/c/generic/device/clock_dev.c =================================================================== --- uspace/lib/c/generic/device/clock_dev.c (revision 762083bc8a2d6259a231487a7f1d20a786ff0a6b) +++ uspace/lib/c/generic/device/clock_dev.c (revision 762083bc8a2d6259a231487a7f1d20a786ff0a6b) @@ -0,0 +1,107 @@ +/* + * Copyright (c) 2012 Maurizio Lombardi + * 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 libc + * @{ + */ +/** @file + */ + +#include +#include +#include +#include +#include + +/** Read the current time from the device + * + * @param sess Session of the device + * @param t The current time that will be read from the device + * + * @return EOK on success or a negative error code + */ +int +clock_dev_time_get(async_sess_t *sess, struct tm *t) +{ + aid_t req; + int ret; + + async_exch_t *exch = async_exchange_begin(sess); + + req = async_send_1(exch, DEV_IFACE_ID(CLOCK_DEV_IFACE), + CLOCK_DEV_TIME_GET, NULL); + ret = async_data_read_start(exch, t, sizeof(*t)); + + async_exchange_end(exch); + + sysarg_t rc; + if (ret != EOK) { + async_wait_for(req, &rc); + if (rc == EOK) + return ret; + } + + async_wait_for(req, &rc); + return (int)rc; +} + +/** Set the current time + * + * @param sess Session of the device + * @param t The current time that will be written to the device + * + * @return EOK on success or a negative error code + */ +int +clock_dev_time_set(async_sess_t *sess, struct tm *t) +{ + aid_t req; + int ret; + + async_exch_t *exch = async_exchange_begin(sess); + + req = async_send_1(exch, DEV_IFACE_ID(CLOCK_DEV_IFACE), + CLOCK_DEV_TIME_SET, NULL); + ret = async_data_write_start(exch, t, sizeof(*t)); + + async_exchange_end(exch); + + sysarg_t rc; + if (ret != EOK) { + async_wait_for(req, &rc); + if (rc == EOK) + return ret; + } + + async_wait_for(req, &rc); + return (int)rc; +} + +/** @} + */ + Index: uspace/lib/c/generic/fibril_synch.c =================================================================== --- uspace/lib/c/generic/fibril_synch.c (revision 111d2d6731b1fbc5a2181c92094ca7b8dbaf9d2f) +++ uspace/lib/c/generic/fibril_synch.c (revision 762083bc8a2d6259a231487a7f1d20a786ff0a6b) @@ -379,5 +379,5 @@ futex_down(&async_futex); if (timeout) { - gettimeofday(&wdata.to_event.expires, NULL); + getuptime(&wdata.to_event.expires); tv_add(&wdata.to_event.expires, timeout); async_insert_timeout(&wdata); Index: uspace/lib/c/generic/time.c =================================================================== --- uspace/lib/c/generic/time.c (revision 111d2d6731b1fbc5a2181c92094ca7b8dbaf9d2f) +++ uspace/lib/c/generic/time.c (revision 762083bc8a2d6259a231487a7f1d20a786ff0a6b) @@ -1,4 +1,6 @@ /* * Copyright (c) 2006 Ondrej Palkovsky + * Copyright (c) 2011 Petr Koupy + * Copyright (c) 2011 Jiri Zarevucky * All rights reserved. * @@ -43,5 +45,14 @@ #include #include +#include +#include +#include +#include #include +#include +#include +#include + +#define ASCTIME_BUF_LEN 26 /** Pointer to kernel shared variables with time */ @@ -52,4 +63,337 @@ } *ktime = NULL; +/* 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) + +/** + * Checks whether the year is a leap year. + * + * @param year Year since 1900 (e.g. for 1970, the value is 70). + * @return true if year is a leap year, false otherwise + */ +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; +} + +/** + * Returns how many days there are in the given month of the given year. + * Note that year is only taken into account if month is February. + * + * @param year Year since 1900 (can be negative). + * @param mon Month of the year. 0 for January, 11 for December. + * @return Number of days in the specified month. + */ +static int _days_in_month(time_t year, time_t mon) +{ + assert(mon >= 0 && mon <= 11); + + static int month_days[] = + { 31, 0, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 }; + + if (mon == 1) { + year += 1900; + /* february */ + return _is_leap_year(year) ? 29 : 28; + } else { + return month_days[mon]; + } +} + +/** + * For specified year, month and day of month, returns which day of that year + * it is. + * + * For example, given date 2011-01-03, the corresponding expression is: + * _day_of_year(111, 0, 3) == 2 + * + * @param year Year (year 1900 = 0, can be negative). + * @param mon Month (January = 0). + * @param mday Day of month (First day is 1). + * @return Day of year (First day is 0). + */ +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. + * Used by some functions in this file. + * + * @param op1 Dividend. + * @param op2 Divisor. + * @return Rounded quotient. + */ +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. + * Used by some functions in this file. + * + * @param op1 Dividend. + * @param op2 Divisor. + * @return Remainder. + */ +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; +} + +/** + * Number of days since the Epoch. + * Epoch is 1970-01-01, which is also equal to day 0. + * + * @param year Year (year 1900 = 0, may be negative). + * @param mon Month (January = 0). + * @param mday Day of month (first day = 1). + * @return Number of days since the Epoch. + */ +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); +} + +/** + * Seconds since the Epoch. see also _days_since_epoch(). + * + * @param tm Normalized broken-down time. + * @return Number of seconds since the epoch, not counting leap seconds. + */ +static time_t _secs_since_epoch(const struct 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; +} + +/** + * Which day of week the specified date is. + * + * @param year Year (year 1900 = 0). + * @param mon Month (January = 0). + * @param mday Day of month (first = 1). + * @return Day of week (Sunday = 0). + */ +static int _day_of_week(time_t year, time_t mon, time_t mday) +{ + /* 1970-01-01 is Thursday */ + return _floor_mod((_days_since_epoch(year, mon, mday) + 4), 7); +} + +/** + * Normalizes the broken-down time and optionally adds specified amount of + * seconds. + * + * @param tm Broken-down time to normalize. + * @param sec_add Seconds to add. + * @return 0 on success, -1 on overflow + */ +static int _normalize_time(struct tm *tm, time_t sec_add) +{ + // TODO: DST correction + + /* Set initial values. */ + time_t sec = tm->tm_sec + sec_add; + time_t min = tm->tm_min; + time_t hour = tm->tm_hour; + time_t day = tm->tm_mday - 1; + time_t mon = tm->tm_mon; + time_t year = tm->tm_year; + + /* Adjust time. */ + min += _floor_div(sec, SECS_PER_MIN); + sec = _floor_mod(sec, SECS_PER_MIN); + hour += _floor_div(min, MINS_PER_HOUR); + min = _floor_mod(min, MINS_PER_HOUR); + day += _floor_div(hour, HOURS_PER_DAY); + hour = _floor_mod(hour, HOURS_PER_DAY); + + /* Adjust month. */ + year += _floor_div(mon, 12); + mon = _floor_mod(mon, 12); + + /* Now the difficult part - days of month. */ + + /* First, deal with whole cycles of 400 years = 146097 days. */ + year += _floor_div(day, 146097) * 400; + day = _floor_mod(day, 146097); + + /* Then, go in one year steps. */ + if (mon <= 1) { + /* January and February. */ + while (day > 365) { + day -= _is_leap_year(year) ? 366 : 365; + year++; + } + } else { + /* Rest of the year. */ + while (day > 365) { + day -= _is_leap_year(year + 1) ? 366 : 365; + year++; + } + } + + /* Finally, finish it off month per month. */ + while (day >= _days_in_month(year, mon)) { + day -= _days_in_month(year, mon); + mon++; + if (mon >= 12) { + mon -= 12; + year++; + } + } + + /* Calculate the remaining two fields. */ + tm->tm_yday = _day_of_year(year, mon, day + 1); + tm->tm_wday = _day_of_week(year, mon, day + 1); + + /* And put the values back to the struct. */ + tm->tm_sec = (int) sec; + tm->tm_min = (int) min; + tm->tm_hour = (int) hour; + tm->tm_mday = (int) day + 1; + tm->tm_mon = (int) mon; + + /* Casts to work around libc brain-damage. */ + if (year > ((int)INT_MAX) || year < ((int)INT_MIN)) { + tm->tm_year = (year < 0) ? ((int)INT_MIN) : ((int)INT_MAX); + return -1; + } + + tm->tm_year = (int) year; + return 0; +} + +/** + * 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 since 1900. + * @return Offset of week-based year relative to calendar year. + */ +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. + * + * @param tm Normalized broken-down time. + * @return Week-based year. + */ +static int _wbyear(const struct 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 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 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 tm *tm) +{ + int first_day = (1 - _day_of_week(tm->tm_year, 0, 1)) % 7; + return (tm->tm_yday - first_day + 7) / 7; +} + +/******************************************************************************/ + + /** Add microseconds to given timeval. * @@ -139,4 +483,67 @@ */ int gettimeofday(struct timeval *tv, struct timezone *tz) +{ + int rc; + struct tm t; + category_id_t cat_id; + size_t svc_cnt; + service_id_t *svc_ids = NULL; + service_id_t svc_id; + char *svc_name = NULL; + + static async_sess_t *clock_conn = NULL; + + if (tz) { + tz->tz_minuteswest = 0; + tz->tz_dsttime = DST_NONE; + } + + if (clock_conn == NULL) { + rc = loc_category_get_id("clock", &cat_id, IPC_FLAG_BLOCKING); + if (rc != EOK) + goto ret_uptime; + + rc = loc_category_get_svcs(cat_id, &svc_ids, &svc_cnt); + if (rc != EOK) + goto ret_uptime; + + if (svc_cnt == 0) + goto ret_uptime; + + rc = loc_service_get_name(svc_ids[0], &svc_name); + if (rc != EOK) + goto ret_uptime; + + rc = loc_service_get_id(svc_name, &svc_id, 0); + if (rc != EOK) + goto ret_uptime; + + clock_conn = loc_service_connect(EXCHANGE_SERIALIZE, + svc_id, IPC_FLAG_BLOCKING); + if (!clock_conn) + goto ret_uptime; + } + + rc = clock_dev_time_get(clock_conn, &t); + if (rc != EOK) + goto ret_uptime; + + tv->tv_usec = 0; + tv->tv_sec = mktime(&t); + + free(svc_name); + free(svc_ids); + + return EOK; + +ret_uptime: + + free(svc_name); + free(svc_ids); + + return getuptime(tv); +} + +int getuptime(struct timeval *tv) { if (ktime == NULL) { @@ -160,9 +567,4 @@ } - if (tz) { - tz->tz_minuteswest = 0; - tz->tz_dsttime = DST_NONE; - } - sysarg_t s2 = ktime->seconds2; @@ -178,5 +580,5 @@ } else tv->tv_sec = s1; - + return 0; } @@ -229,4 +631,355 @@ } +/** + * 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 mktime(struct tm *tm) +{ + // TODO: take DST flag into account + // TODO: detect overflow + + _normalize_time(tm, 0); + return _secs_since_epoch(tm); +} + +/** + * Convert time and date to a string, based on a specified format and + * current locale. + * + * @param s Buffer to write string to. + * @param maxsize Size of the buffer. + * @param format Format of the output. + * @param tm Broken-down time to format. + * @return Number of bytes written. + */ +size_t strftime(char *restrict s, size_t maxsize, + const char *restrict format, const struct tm *restrict tm) +{ + assert(s != NULL); + assert(format != NULL); + assert(tm != NULL); + + // 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 = 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; +} + + +/** Converts a time value to a broken-down UTC time + * + * @param time Time to convert + * @param result Structure to store the result to + * + * @return EOK or a negative error code + */ +int utctime2tm(const time_t time, struct tm *restrict result) +{ + assert(result != NULL); + + /* Set result to epoch. */ + result->tm_sec = 0; + result->tm_min = 0; + result->tm_hour = 0; + result->tm_mday = 1; + result->tm_mon = 0; + result->tm_year = 70; /* 1970 */ + + if (_normalize_time(result, time) == -1) + return EOVERFLOW; + + return EOK; +} + +/** Converts a time value to a null terminated string of the form + * "Wed Jun 30 21:49:08 1993\n" expressed in UTC. + * + * @param time Time to convert. + * @param buf Buffer to store the string to, must be at least + * ASCTIME_BUF_LEN bytes long. + * + * @return EOK or a negative error code. + */ +int utctime2str(const time_t time, char *restrict buf) +{ + struct tm t; + int r; + + if ((r = utctime2tm(time, &t)) != EOK) + return r; + + tm2str(&t, buf); + return EOK; +} + + +/** + * Converts broken-down time to a string in format + * "Sun Jan 1 00:00:00 1970\n". (Obsolete) + * + * @param timeptr Broken-down time structure. + * @param buf Buffer to store string to, must be at least ASCTIME_BUF_LEN + * bytes long. + */ +void tm2str(const struct 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); +} + +/** + * Converts a time value to a broken-down local time, expressed relative + * to the user's specified timezone. + * + * @param timer Time to convert. + * @param result Structure to store the result to. + * + * @return EOK on success or a negative error code. + */ +int localtime2tm(const time_t time, struct tm *restrict result) +{ + // TODO: deal with timezone + // currently assumes system and all times are in GMT + + /* Set result to epoch. */ + result->tm_sec = 0; + result->tm_min = 0; + result->tm_hour = 0; + result->tm_mday = 1; + result->tm_mon = 0; + result->tm_year = 70; /* 1970 */ + + if (_normalize_time(result, time) == -1) + return EOVERFLOW; + + return EOK; +} + +/** + * Converts the calendar time to a null terminated string + * of the form "Wed Jun 30 21:49:08 1993\n" expressed relative to the + * user's specified timezone. + * + * @param timer Time to convert. + * @param buf Buffer to store the string to. Must be at least + * ASCTIME_BUF_LEN bytes long. + * + * @return EOK on success or a negative error code. + */ +int localtime2str(const time_t time, char *buf) +{ + struct tm loctime; + int r; + + if ((r = localtime2tm(time, &loctime)) != EOK) + return r; + + tm2str(&loctime, buf); + + return EOK; +} + +/** + * Calculate the difference between two times, in seconds. + * + * @param time1 First time. + * @param time0 Second time. + * @return Time in seconds. + */ +double difftime(time_t time1, time_t time0) +{ + return (double) (time1 - time0); +} + /** @} */ Index: uspace/lib/c/include/device/clock_dev.h =================================================================== --- uspace/lib/c/include/device/clock_dev.h (revision 762083bc8a2d6259a231487a7f1d20a786ff0a6b) +++ uspace/lib/c/include/device/clock_dev.h (revision 762083bc8a2d6259a231487a7f1d20a786ff0a6b) @@ -0,0 +1,50 @@ +/* + * Copyright (c) 2012 Maurizio Lombardi + * 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 libc + * @{ + */ +/** @file + */ + +#ifndef LIBC_DEVICE_CLOCK_DEV_H_ +#define LIBC_DEVICE_CLOCK_DEV_H_ + +#include +#include + +typedef enum { + CLOCK_DEV_TIME_GET = 0, + CLOCK_DEV_TIME_SET, +} clock_dev_method_t; + +extern int clock_dev_time_get(async_sess_t *, struct tm *); +extern int clock_dev_time_set(async_sess_t *, struct tm *); + +#endif + Index: uspace/lib/c/include/ipc/clock_ctl.h =================================================================== --- uspace/lib/c/include/ipc/clock_ctl.h (revision 762083bc8a2d6259a231487a7f1d20a786ff0a6b) +++ uspace/lib/c/include/ipc/clock_ctl.h (revision 762083bc8a2d6259a231487a7f1d20a786ff0a6b) @@ -0,0 +1,39 @@ +/* + * Copyright (c) 2012 Maurizio Lombardi + * 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. + */ + +#ifndef LIBC_IPC_CLOCK_CTL_H_ +#define LIBC_IPC_CLOCK_CTL_H_ + +#include + +typedef enum { + CLOCK_GET_BATTERY_STATUS = DEV_FIRST_CUSTOM_METHOD, +} clock_ctl_t; + +#endif + Index: uspace/lib/c/include/ipc/dev_iface.h =================================================================== --- uspace/lib/c/include/ipc/dev_iface.h (revision 111d2d6731b1fbc5a2181c92094ca7b8dbaf9d2f) +++ uspace/lib/c/include/ipc/dev_iface.h (revision 762083bc8a2d6259a231487a7f1d20a786ff0a6b) @@ -54,4 +54,6 @@ /** Interface provided by USB HID devices. */ USBHID_DEV_IFACE, + /** Interface provided by Real Time Clock devices */ + CLOCK_DEV_IFACE, /** Interface provided by AHCI devices. */ AHCI_DEV_IFACE, Index: uspace/lib/c/include/sys/time.h =================================================================== --- uspace/lib/c/include/sys/time.h (revision 111d2d6731b1fbc5a2181c92094ca7b8dbaf9d2f) +++ uspace/lib/c/include/sys/time.h (revision 762083bc8a2d6259a231487a7f1d20a786ff0a6b) @@ -1,4 +1,6 @@ /* * Copyright (c) 2006 Ondrej Palkovsky + * Copyright (c) 2011 Petr Koupy + * Copyright (c) 2011 Jiri Zarevucky * All rights reserved. * @@ -39,4 +41,5 @@ #define DST_NONE 0 +#define ASCTIME_BUF_LEN 26 typedef long time_t; @@ -45,4 +48,16 @@ typedef uint32_t useconds_t; typedef uint32_t mseconds_t; + +struct tm { + int tm_sec; /* Seconds [0,60]. */ + int tm_min; /* Minutes [0,59]. */ + int tm_hour; /* Hour [0,23]. */ + int tm_mday; /* Day of month [1,31]. */ + int tm_mon; /* Month of year [0,11]. */ + int tm_year; /* Years since 1900. */ + int tm_wday; /* Day of week [0,6] (Sunday = 0). */ + int tm_yday; /* Day of year [0,365]. */ + int tm_isdst; /* Daylight Savings flag. */ +}; struct timeval { @@ -61,6 +76,17 @@ extern int tv_gteq(struct timeval *tv1, struct timeval *tv2); extern int gettimeofday(struct timeval *tv, struct timezone *tz); +extern int getuptime(struct timeval *tv); extern void udelay(useconds_t); + +extern time_t mktime(struct tm *tm); +extern int utctime2tm(const time_t time, struct tm *result); +extern int utctime2str(const time_t time, char *buf); +extern void tm2str(const struct tm *timeptr, char *buf); +extern int localtime2tm(const time_t time, struct tm *result); +extern int localtime2str(const time_t time, char *buf); +extern double difftime(time_t time1, time_t time0); +extern size_t strftime(char *restrict s, size_t maxsize, + const char *restrict format, const struct tm *restrict tm); #endif Index: uspace/lib/drv/Makefile =================================================================== --- uspace/lib/drv/Makefile (revision 111d2d6731b1fbc5a2181c92094ca7b8dbaf9d2f) +++ uspace/lib/drv/Makefile (revision 762083bc8a2d6259a231487a7f1d20a786ff0a6b) @@ -46,4 +46,5 @@ generic/remote_usbhc.c \ generic/remote_usbhid.c \ + generic/remote_clock_dev.c \ generic/remote_ahci.c Index: uspace/lib/drv/generic/dev_iface.c =================================================================== --- uspace/lib/drv/generic/dev_iface.c (revision 111d2d6731b1fbc5a2181c92094ca7b8dbaf9d2f) +++ uspace/lib/drv/generic/dev_iface.c (revision 762083bc8a2d6259a231487a7f1d20a786ff0a6b) @@ -41,4 +41,5 @@ #include "remote_hw_res.h" #include "remote_char_dev.h" +#include "remote_clock_dev.h" #include "remote_graph_dev.h" #include "remote_nic.h" @@ -59,4 +60,5 @@ &remote_usbhc_iface, &remote_usbhid_iface, + &remote_clock_dev_iface, &remote_ahci_iface } Index: uspace/lib/drv/generic/remote_clock_dev.c =================================================================== --- uspace/lib/drv/generic/remote_clock_dev.c (revision 762083bc8a2d6259a231487a7f1d20a786ff0a6b) +++ uspace/lib/drv/generic/remote_clock_dev.c (revision 762083bc8a2d6259a231487a7f1d20a786ff0a6b) @@ -0,0 +1,143 @@ +/* + * Copyright (c) 2012 Maurizio Lombardi + * 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 libdrv + * @{ + */ +/** @file + */ + +#include +#include +#include + +#include +#include + +static void remote_clock_time_get(ddf_fun_t *, void *, ipc_callid_t, + ipc_call_t *); +static void remote_clock_time_set(ddf_fun_t *, void *, ipc_callid_t, + ipc_call_t *); + +/** Remote clock interface operations */ +static remote_iface_func_ptr_t remote_clock_dev_iface_ops[] = { + &remote_clock_time_get, + &remote_clock_time_set, +}; + +/** Remote clock interface structure + * + * Interface for processing requests from remote clients + * addressed by the clock interface. + */ +remote_iface_t remote_clock_dev_iface = { + .method_count = sizeof(remote_clock_dev_iface_ops) / + sizeof(remote_iface_func_ptr_t), + .methods = remote_clock_dev_iface_ops, +}; + +/** Process the time_get() request from the remote client + * + * @param fun The function from which the time is read + * @param ops The local ops structure + */ +static void +remote_clock_time_get(ddf_fun_t *fun, void *ops, ipc_callid_t callid, + ipc_call_t *call) +{ + clock_dev_ops_t *clock_dev_ops = (clock_dev_ops_t *) ops; + ipc_callid_t cid; + struct tm t; + int rc; + size_t len; + + if (!async_data_read_receive(&cid, &len)) { + /* TODO: Handle protocol error */ + async_answer_0(callid, EINVAL); + return; + } + + if (!clock_dev_ops->time_get) { + /* The driver does not provide the time_get() functionality */ + async_data_read_finalize(cid, NULL, 0); + async_answer_0(callid, ENOTSUP); + return; + } + + rc = (*clock_dev_ops->time_get)(fun, &t); + + if (rc != EOK) { + /* Some error occurred */ + async_data_read_finalize(cid, NULL, 0); + async_answer_0(callid, rc); + return; + } + + /* The operation was successful */ + async_data_read_finalize(cid, &t, sizeof(struct tm)); + async_answer_0(callid, rc); +} + +/** Process the write request from the remote client + * + * @param fun The function to which the data are written + * @param ops The local ops structure + */ +static void remote_clock_time_set(ddf_fun_t *fun, void *ops, + ipc_callid_t callid, ipc_call_t *call) +{ + clock_dev_ops_t *clock_dev_ops = (clock_dev_ops_t *) ops; + int rc; + struct tm t; + ipc_callid_t cid; + size_t len; + + if (!async_data_write_receive(&cid, &len)) { + /* TODO: Handle protocol error */ + async_answer_0(callid, EINVAL); + return; + } + + if (!clock_dev_ops->time_set) { + /* The driver does not support the time_set() functionality */ + async_data_write_finalize(cid, NULL, 0); + async_answer_0(callid, ENOTSUP); + return; + } + + async_data_write_finalize(cid, &t, sizeof(struct tm)); + + rc = (*clock_dev_ops->time_set)(fun, &t); + + async_answer_0(callid, rc); +} + +/** + * @} + */ + Index: uspace/lib/drv/include/ops/clock_dev.h =================================================================== --- uspace/lib/drv/include/ops/clock_dev.h (revision 762083bc8a2d6259a231487a7f1d20a786ff0a6b) +++ uspace/lib/drv/include/ops/clock_dev.h (revision 762083bc8a2d6259a231487a7f1d20a786ff0a6b) @@ -0,0 +1,50 @@ +/* + * Copyright (c) 2012 Maurizio Lombardi + * 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 libdrv + * @{ + */ +/** @file + */ + +#ifndef LIBDRV_OPS_CLOCK_DEV_H_ +#define LIBDRV_OPS_CLOCK_DEV_H_ + +#include +#include "../ddf/driver.h" + +typedef struct { + int (*time_get)(ddf_fun_t *, struct tm *); + int (*time_set)(ddf_fun_t *, struct tm *); +} clock_dev_ops_t; + +#endif + +/** + * @} + */ Index: uspace/lib/drv/include/remote_clock_dev.h =================================================================== --- uspace/lib/drv/include/remote_clock_dev.h (revision 762083bc8a2d6259a231487a7f1d20a786ff0a6b) +++ uspace/lib/drv/include/remote_clock_dev.h (revision 762083bc8a2d6259a231487a7f1d20a786ff0a6b) @@ -0,0 +1,45 @@ +/* + * Copyright (c) 2012 Maurizio Lombardi + * 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 libdrv + * @{ + */ +/** @file + */ + +#ifndef LIBDRV_REMOTE_CLOCK_DEV_H_ +#define LIBDRV_REMOTE_CLOCK_DEV_H_ + +extern remote_iface_t remote_clock_dev_iface; + +#endif + +/** + * @} + */ + Index: uspace/lib/posix/time.c =================================================================== --- uspace/lib/posix/time.c (revision 111d2d6731b1fbc5a2181c92094ca7b8dbaf9d2f) +++ uspace/lib/posix/time.c (revision 762083bc8a2d6259a231487a7f1d20a786ff0a6b) @@ -61,338 +61,4 @@ */ - - -/* 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) - -/** - * Checks whether the year is a leap year. - * - * @param year Year since 1900 (e.g. for 1970, the value is 70). - * @return true if year is a leap year, false otherwise - */ -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; -} - -/** - * Returns how many days there are in the given month of the given year. - * Note that year is only taken into account if month is February. - * - * @param year Year since 1900 (can be negative). - * @param mon Month of the year. 0 for January, 11 for December. - * @return Number of days in the specified month. - */ -static int _days_in_month(time_t year, time_t mon) -{ - assert(mon >= 0 && mon <= 11); - - static int month_days[] = - { 31, 0, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 }; - - if (mon == 1) { - year += 1900; - /* february */ - return _is_leap_year(year) ? 29 : 28; - } else { - return month_days[mon]; - } -} - -/** - * For specified year, month and day of month, returns which day of that year - * it is. - * - * For example, given date 2011-01-03, the corresponding expression is: - * _day_of_year(111, 0, 3) == 2 - * - * @param year Year (year 1900 = 0, can be negative). - * @param mon Month (January = 0). - * @param mday Day of month (First day is 1). - * @return Day of year (First day is 0). - */ -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. - * Used by some functions in this file. - * - * @param op1 Divident. - * @param op2 Divisor. - * @return Rounded quotient. - */ -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. - * Used by some functions in this file. - * - * @param op1 Divident. - * @param op2 Divisor. - * @return Remainder. - */ -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; -} - -/** - * Number of days since the Epoch. - * Epoch is 1970-01-01, which is also equal to day 0. - * - * @param year Year (year 1900 = 0, may be negative). - * @param mon Month (January = 0). - * @param mday Day of month (first day = 1). - * @return Number of days since the Epoch. - */ -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); -} - -/** - * Seconds since the Epoch. see also _days_since_epoch(). - * - * @param tm Normalized broken-down time. - * @return Number of seconds since the epoch, not counting leap seconds. - */ -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; -} - -/** - * Which day of week the specified date is. - * - * @param year Year (year 1900 = 0). - * @param mon Month (January = 0). - * @param mday Day of month (first = 1). - * @return Day of week (Sunday = 0). - */ -static int _day_of_week(time_t year, time_t mon, time_t mday) -{ - /* 1970-01-01 is Thursday */ - return _floor_mod((_days_since_epoch(year, mon, mday) + 4), 7); -} - -/** - * Normalizes the broken-down time and optionally adds specified amount of - * seconds. - * - * @param tm Broken-down time to normalize. - * @param sec_add Seconds to add. - * @return 0 on success, -1 on overflow - */ -static int _normalize_time(struct posix_tm *tm, time_t sec_add) -{ - // TODO: DST correction - - /* Set initial values. */ - time_t sec = tm->tm_sec + sec_add; - time_t min = tm->tm_min; - time_t hour = tm->tm_hour; - time_t day = tm->tm_mday - 1; - time_t mon = tm->tm_mon; - time_t year = tm->tm_year; - - /* Adjust time. */ - min += _floor_div(sec, SECS_PER_MIN); - sec = _floor_mod(sec, SECS_PER_MIN); - hour += _floor_div(min, MINS_PER_HOUR); - min = _floor_mod(min, MINS_PER_HOUR); - day += _floor_div(hour, HOURS_PER_DAY); - hour = _floor_mod(hour, HOURS_PER_DAY); - - /* Adjust month. */ - year += _floor_div(mon, 12); - mon = _floor_mod(mon, 12); - - /* Now the difficult part - days of month. */ - - /* First, deal with whole cycles of 400 years = 146097 days. */ - year += _floor_div(day, 146097) * 400; - day = _floor_mod(day, 146097); - - /* Then, go in one year steps. */ - if (mon <= 1) { - /* January and February. */ - while (day > 365) { - day -= _is_leap_year(year) ? 366 : 365; - year++; - } - } else { - /* Rest of the year. */ - while (day > 365) { - day -= _is_leap_year(year + 1) ? 366 : 365; - year++; - } - } - - /* Finally, finish it off month per month. */ - while (day >= _days_in_month(year, mon)) { - day -= _days_in_month(year, mon); - mon++; - if (mon >= 12) { - mon -= 12; - year++; - } - } - - /* Calculate the remaining two fields. */ - tm->tm_yday = _day_of_year(year, mon, day + 1); - tm->tm_wday = _day_of_week(year, mon, day + 1); - - /* And put the values back to the struct. */ - tm->tm_sec = (int) sec; - tm->tm_min = (int) min; - tm->tm_hour = (int) hour; - tm->tm_mday = (int) day + 1; - tm->tm_mon = (int) mon; - - /* Casts to work around libc brain-damage. */ - if (year > ((int)INT_MAX) || year < ((int)INT_MIN)) { - tm->tm_year = (year < 0) ? ((int)INT_MIN) : ((int)INT_MAX); - return -1; - } - - tm->tm_year = (int) year; - return 0; -} - -/** - * 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 since 1900. - * @return Offset of week-based year relative to calendar year. - */ -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. - * - * @param tm Normalized broken-down time. - * @return Week-based year. - */ -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; @@ -412,47 +78,4 @@ /** - * Calculate the difference between two times, in seconds. - * - * @param time1 First time. - * @param time0 Second time. - * @return Time in seconds. - */ -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 - - _normalize_time(tm, 0); - return _secs_since_epoch(tm); -} - -/** - * Converts a time value to a broken-down UTC time. - * - * @param timer Time to convert. - * @return Normalized broken-down time in UTC, NULL on overflow. - */ -struct posix_tm *posix_gmtime(const time_t *timer) -{ - assert(timer != NULL); - - static struct posix_tm result; - return posix_gmtime_r(timer, &result); -} - -/** * Converts a time value to a broken-down UTC time. * @@ -461,20 +84,10 @@ * @return Value of result on success, NULL on overflow. */ -struct posix_tm *posix_gmtime_r(const time_t *restrict timer, - struct posix_tm *restrict result) -{ - assert(timer != NULL); - assert(result != NULL); - - /* Set result to epoch. */ - result->tm_sec = 0; - result->tm_min = 0; - result->tm_hour = 0; - result->tm_mday = 1; - result->tm_mon = 0; - result->tm_year = 70; /* 1970 */ - - if (_normalize_time(result, *timer) == -1) { - errno = EOVERFLOW; +struct tm *posix_gmtime_r(const time_t *restrict timer, + struct tm *restrict result) +{ + int rc = utctime2tm(*timer, result); + if (rc != EOK) { + errno = rc; return NULL; } @@ -484,13 +97,16 @@ /** - * Converts a time value to a broken-down local time. - * - * @param timer Time to convert. - * @return Normalized broken-down time in local timezone, NULL on overflow. - */ -struct posix_tm *posix_localtime(const time_t *timer) -{ - static struct posix_tm result; - return posix_localtime_r(timer, &result); + * Converts a time value to a broken-down UTC time. + * (non reentrant version) + * + * @param timep Time to convert + * @return Pointer to a statically allocated structure that stores + * the result, NULL in case of error. + */ +struct tm *posix_gmtime(const time_t *restrict timep) +{ + static struct tm result; + + return posix_gmtime_r(timep, &result); } @@ -502,6 +118,6 @@ * @return Value of result on success, NULL on overflow. */ -struct posix_tm *posix_localtime_r(const time_t *restrict timer, - struct posix_tm *restrict result) +struct tm *posix_localtime_r(const time_t *restrict timer, + struct tm *restrict result) { // TODO: deal with timezone @@ -511,14 +127,16 @@ /** - * Converts broken-down time to a string in format - * "Sun Jan 1 00:00:00 1970\n". (Obsolete) - * - * @param timeptr Broken-down time structure. - * @return Pointer to a statically allocated string. - */ -char *posix_asctime(const struct posix_tm *timeptr) -{ - static char buf[ASCTIME_BUF_LEN]; - return posix_asctime_r(timeptr, buf); + * Converts a time value to a broken-down local time. + * (non reentrant version) + * + * @param timep Time to convert. + * @return Pointer to a statically allocated structure that stores + * the result, NULL in case of error. + */ +struct tm *posix_localtime(const time_t *restrict timep) +{ + static struct tm result; + + return posix_localtime_r(timep, &result); } @@ -532,250 +150,61 @@ * @return Value of buf. */ -char *posix_asctime_r(const struct posix_tm *restrict timeptr, +char *posix_asctime_r(const struct 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); - + tm2str(timeptr, buf); return buf; } /** - * Equivalent to asctime(localtime(clock)). - * - * @param timer Time to convert. - * @return Pointer to a statically allocated string holding the date. - */ -char *posix_ctime(const time_t *timer) -{ - struct posix_tm *loctime = posix_localtime(timer); - if (loctime == NULL) { - return NULL; - } - return posix_asctime(loctime); -} - -/** - * Reentrant variant of ctime(). + * Convers broken-down time to a string in format + * "Sun Jan 1 00:00:00 1970\n". (Obsolete) + * (non reentrant version) + * + * @param timeptr Broken-down time structure. + * @return Pointer to a statically allocated buffer that stores + * the result, NULL in case of error. + */ +char *posix_asctime(const struct tm *restrict timeptr) +{ + static char buf[ASCTIME_BUF_LEN]; + + return posix_asctime_r(timeptr, buf); +} + +/** + * Converts the calendar time to a string in format + * "Sun Jan 1 00:00:00 1970\n" (Obsolete) * * @param timer Time to convert. * @param buf Buffer to store string to. Must be at least ASCTIME_BUF_LEN * bytes long. - * @return Pointer to buf on success, NULL on falure. + * @return Pointer to buf on success, NULL on failure. */ char *posix_ctime_r(const time_t *timer, char *buf) { - struct posix_tm loctime; - if (posix_localtime_r(timer, &loctime) == NULL) { + int r = localtime2str(*timer, buf); + if (r != EOK) { + errno = r; return NULL; } - return posix_asctime_r(&loctime, buf); -} - -/** - * Convert time and date to a string, based on a specified format and - * current locale. - * - * @param s Buffer to write string to. - * @param maxsize Size of the buffer. - * @param format Format of the output. - * @param tm Broken-down time to format. - * @return Number of bytes written. - */ -size_t posix_strftime(char *restrict s, size_t maxsize, - const char *restrict format, const struct posix_tm *restrict tm) -{ - assert(s != NULL); - assert(format != NULL); - assert(tm != NULL); - - // 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; + + return buf; +} + +/** + * Converts the calendar time to a string in format + * "Sun Jan 1 00:00:00 1970\n" (Obsolete) + * (non reentrant version) + * + * @param timep Time to convert. + * @return Pointer to a statically allocated buffer that stores + * the result, NULL in case of error. + */ +char *posix_ctime(const time_t *timep) +{ + static char buf[ASCTIME_BUF_LEN]; + + return posix_ctime_r(timep, buf); } @@ -894,5 +323,6 @@ 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); + total_cycles = (posix_clock_t) (task_stats->kcycles + + task_stats->ucycles); free(task_stats); task_stats = 0; Index: uspace/lib/posix/time.h =================================================================== --- uspace/lib/posix/time.h (revision 111d2d6731b1fbc5a2181c92094ca7b8dbaf9d2f) +++ uspace/lib/posix/time.h (revision 762083bc8a2d6259a231487a7f1d20a786ff0a6b) @@ -63,21 +63,6 @@ #endif -#undef ASCTIME_BUF_LEN -#define ASCTIME_BUF_LEN 26 - #undef CLOCK_REALTIME #define CLOCK_REALTIME ((posix_clockid_t) 0) - -struct posix_tm { - int tm_sec; /* Seconds [0,60]. */ - int tm_min; /* Minutes [0,59]. */ - int tm_hour; /* Hour [0,23]. */ - int tm_mday; /* Day of month [1,31]. */ - int tm_mon; /* Month of year [0,11]. */ - int tm_year; /* Years since 1900. */ - int tm_wday; /* Day of week [0,6] (Sunday = 0). */ - int tm_yday; /* Day of year [0,365]. */ - int tm_isdst; /* Daylight Savings flag. */ -}; struct posix_timespec { @@ -99,24 +84,18 @@ extern void posix_tzset(void); -/* Elapsed Time */ -extern double posix_difftime(time_t time1, time_t time0); - /* Broken-down Time */ -extern time_t posix_mktime(struct posix_tm *tm); -extern struct posix_tm *posix_gmtime(const time_t *timer); -extern struct posix_tm *posix_gmtime_r(const time_t *restrict timer, - struct posix_tm *restrict result); -extern struct posix_tm *posix_localtime(const time_t *timer); -extern struct posix_tm *posix_localtime_r(const time_t *restrict timer, - struct posix_tm *restrict result); +extern struct tm *posix_gmtime_r(const time_t *restrict timer, + struct tm *restrict result); +extern struct tm *posix_gmtime(const time_t *restrict timep); +extern struct tm *posix_localtime_r(const time_t *restrict timer, + struct tm *restrict result); +extern struct tm *posix_localtime(const time_t *restrict timep); /* Formatting Calendar Time */ -extern char *posix_asctime(const struct posix_tm *timeptr); -extern char *posix_asctime_r(const struct posix_tm *restrict timeptr, +extern char *posix_asctime_r(const struct tm *restrict timeptr, char *restrict buf); +extern char *posix_asctime(const struct tm *restrict timeptr); +extern char *posix_ctime_r(const time_t *timer, char *buf); extern char *posix_ctime(const time_t *timer); -extern char *posix_ctime_r(const time_t *timer, char *buf); -extern size_t posix_strftime(char *restrict s, size_t maxsize, - const char *restrict format, const struct posix_tm *restrict tm); /* Clocks */ @@ -134,27 +113,22 @@ #ifndef LIBPOSIX_INTERNAL - #define tm posix_tm - #define timespec posix_timespec - #define itimerspec posix_itimerspec - #define timer_t posix_timer_t + #define timespec posix_timespec + #define itimerspec posix_itimerspec + #define timer_t posix_timer_t - #define daylight posix_daylight - #define timezone posix_timezone - #define tzname posix_tzname - #define tzset posix_tzset + #define daylight posix_daylight + #define timezone posix_timezone + #define tzname posix_tzname + #define tzset posix_tzset - #define difftime posix_difftime + #define gmtime_r posix_gmtime_r + #define gmtime posix_gmtime + #define localtime_r posix_localtime_r + #define localtime posix_localtime - #define mktime posix_mktime - #define gmtime posix_gmtime - #define gmtime_r posix_gmtime_r - #define localtime posix_localtime - #define localtime_r posix_localtime_r - - #define asctime posix_asctime - #define asctime_r posix_asctime_r - #define ctime posix_ctime - #define ctime_r posix_ctime_r - #define strftime posix_strftime + #define asctime_r posix_asctime_r + #define asctime posix_asctime + #define ctime_r posix_ctime_r + #define ctime posix_ctime #define clock_getres posix_clock_getres