Changeset bd41ac52 in mainline for uspace/lib

Timestamp:

2018-08-25T22:21:25Z (7 years ago)

Author:

Jakub Jermar <jakub@…>

Branches:

lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export

Children:

cca80a2

Parents:

e2625b1a

Message:

Get rid of sys/time.h

This commit moves the POSIX-like time functionality from libc's
sys/time.h to libposix and introduces C11-like or HelenOS-specific
interfaces to libc.

Specifically, use of sys/time.h, struct timeval, suseconds_t and
gettimeofday is replaced by time.h (C11), struct timespec (C11), usec_t
(HelenOS) and getuptime / getrealtime (HelenOS).

Also attempt to fix the implementation of clock() to return microseconds
(clocks) rather than processor cycles and move it to libc.

Location:

uspace/lib

Files:

• c/generic/async/client.c (modified) (3 diffs)
• c/generic/async/ports.c (modified) (1 diff)
• c/generic/async/server.c (modified) (2 diffs)
• c/generic/io/console.c (modified) (2 diffs)
• c/generic/private/async.h (modified) (1 diff)
• c/generic/private/fibril.h (modified) (1 diff)
• c/generic/private/futex.h (modified) (5 diffs)
• c/generic/private/thread.h (modified) (1 diff)
• c/generic/rndgen.c (modified) (2 diffs)
• c/generic/stdlib.c (modified) (1 diff)
• c/generic/thread/fibril.c (modified) (15 diffs)
• c/generic/thread/fibril_synch.c (modified) (7 diffs)
• c/generic/thread/mpsc.c (modified) (1 diff)
• c/generic/thread/thread.c (modified) (2 diffs)
• c/generic/time.c (modified) (20 diffs)
• c/include/async.h (modified) (3 diffs)
• c/include/ddi.h (modified) (6 diffs)
• c/include/fibril.h (modified) (1 diff)
• c/include/fibril_synch.h (modified) (6 diffs)
• c/include/io/con_srv.h (modified) (2 diffs)
• c/include/io/console.h (modified) (2 diffs)
• c/include/sys/time.h (deleted)
• c/include/time.h (modified) (2 diffs)
• cpp/include/__bits/chrono.hpp (modified) (2 diffs)
• cpp/include/__bits/thread/threading.hpp (modified) (1 diff)
• drv/generic/remote_nic.c (modified) (10 diffs)
• drv/include/nic_iface.h (modified) (1 diff)
• drv/include/ops/nic.h (modified) (2 diffs)
• drv/include/pci_dev_iface.h (modified) (1 diff)
• nic/include/nic.h (modified) (2 diffs)
• nic/include/nic_driver.h (modified) (1 diff)
• nic/include/nic_impl.h (modified) (1 diff)
• nic/src/nic_driver.c (modified) (7 diffs)
• nic/src/nic_impl.c (modified) (4 diffs)
• pcm/include/pcm/format.h (modified) (1 diff)
• pcm/include/pcm/sample_format.h (modified) (1 diff)
• pcut/src/os/helenos.c (modified) (1 diff)
• posix/include/posix/sys/time.h (modified) (1 diff)
• posix/include/posix/sys/types.h (modified) (2 diffs)
• posix/include/posix/time.h (modified) (3 diffs)
• posix/src/internal/common.h (modified) (1 diff)
• posix/src/time.c (modified) (6 diffs)
• usb/include/usb/port.h (modified) (1 diff)
• usb/src/port.c (modified) (1 diff)
• usbhost/include/usb/host/endpoint.h (modified) (2 diffs)
• usbhost/src/endpoint.c (modified) (1 diff)

uspace/lib/c/generic/async/client.c

@@ -110 +110 @@
 #include <assert.h>
 #include <errno.h>
-#include <sys/time.h>
+#include <time.h>
 #include <barrier.h>
 #include <stdbool.h>
@@ -342 +342 @@
  *
  */
-errno_t async_wait_timeout(aid_t amsgid, errno_t *retval, suseconds_t timeout)
+errno_t async_wait_timeout(aid_t amsgid, errno_t *retval, usec_t timeout)
 {
         if (amsgid == 0) {
@@ -359 +359 @@
                 timeout = 0;
 
-        struct timeval expires;
+        struct timespec expires;
         getuptime(&expires);
-        tv_add_diff(&expires, timeout);
+        ts_add_diff(&expires, USEC2NSEC(timeout));
 
         errno_t rc = fibril_wait_timeout(&msg->received, &expires);

uspace/lib/c/generic/async/ports.c

@@ -41 +41 @@
 #include <assert.h>
 #include <errno.h>
-#include <sys/time.h>
+#include <time.h>
 #include <barrier.h>
 #include <stdbool.h>

uspace/lib/c/generic/async/server.c

@@ -110 +110 @@
 #include <assert.h>
 #include <errno.h>
-#include <sys/time.h>
+#include <time.h>
 #include <stdbool.h>
 #include <stdlib.h>
@@ -916 +916 @@
  *
  */
-bool async_get_call_timeout(ipc_call_t *call, suseconds_t usecs)
+bool async_get_call_timeout(ipc_call_t *call, usec_t usecs)
 {
         assert(call);
         assert(fibril_connection);
 
-        struct timeval tv;
-        struct timeval *expires = NULL;
+        struct timespec ts;
+        struct timespec *expires = NULL;
         if (usecs) {
-                getuptime(&tv);
-                tv_add_diff(&tv, usecs);
-                expires = &tv;
+                getuptime(&ts);
+                ts_add_diff(&ts, USEC2NSEC(usecs));
+                expires = &ts;
         }
 

uspace/lib/c/generic/io/console.c

@@ -223 +223 @@
 
 bool console_get_event_timeout(console_ctrl_t *ctrl, cons_event_t *event,
-    suseconds_t *timeout)
-{
-        struct timeval t0;
-        gettimeofday(&t0, NULL);
+    usec_t *timeout)
+{
+        struct timespec t0;
+        getuptime(&t0);
 
         if (ctrl->input_aid == 0) {
@@ -257 +257 @@
 
         /* Update timeout */
-        struct timeval t1;
-        gettimeofday(&t1, NULL);
-        *timeout -= tv_sub_diff(&t1, &t0);
+        struct timespec t1;
+        getuptime(&t1);
+        *timeout -= NSEC2USEC(ts_sub_diff(&t1, &t0));
 
         return true;

uspace/lib/c/generic/private/async.h

@@ -40 +40 @@
 #include <fibril.h>
 #include <fibril_synch.h>
-#include <sys/time.h>
+#include <time.h>
 #include <stdbool.h>
 

uspace/lib/c/generic/private/fibril.h

@@ -81 +81 @@
 
 extern void fibril_wait_for(fibril_event_t *);
-extern errno_t fibril_wait_timeout(fibril_event_t *, const struct timeval *);
+extern errno_t fibril_wait_timeout(fibril_event_t *, const struct timespec *);
 extern void fibril_notify(fibril_event_t *);
 
-extern errno_t fibril_ipc_wait(ipc_call_t *, const struct timeval *);
+extern errno_t fibril_ipc_wait(ipc_call_t *, const struct timespec *);
 extern void fibril_ipc_poke(void);
 

uspace/lib/c/generic/private/futex.h

@@ -102 +102 @@
  *
  */
-static inline errno_t futex_down_composable(futex_t *futex, const struct timeval *expires)
+static inline errno_t futex_down_composable(futex_t *futex,
+    const struct timespec *expires)
 {
         // TODO: Add tests for this.
@@ -109 +110 @@
                 return EOK;
 
-        suseconds_t timeout;
+        usec_t timeout;
 
         if (!expires) {
@@ -119 +120 @@
                         timeout = 1;
                 } else {
-                        struct timeval tv;
+                        struct timespec tv;
                         getuptime(&tv);
-                        timeout = tv_gteq(&tv, expires) ? 1 :
-                            tv_sub_diff(expires, &tv);
+                        timeout = ts_gteq(&tv, expires) ? 1 :
+                            NSEC2USEC(ts_sub_diff(expires, &tv));
                 }
 
@@ -148 +149 @@
 }
 
-static inline errno_t futex_down_timeout(futex_t *futex, const struct timeval *expires)
-{
-        if (expires && expires->tv_sec == 0 && expires->tv_usec == 0) {
+static inline errno_t futex_down_timeout(futex_t *futex,
+    const struct timespec *expires)
+{
+        if (expires && expires->tv_sec == 0 && expires->tv_nsec == 0) {
                 /* Nonblocking down. */
 
@@ -209 +211 @@
          * trydown.
          */
-        struct timeval tv = { .tv_sec = 0, .tv_usec = 0 };
+        struct timespec tv = { .tv_sec = 0, .tv_nsec = 0 };
         return futex_down_timeout(futex, &tv) == EOK;
 }

uspace/lib/c/generic/private/thread.h

@@ -49 +49 @@
 extern void thread_detach(thread_id_t);
 extern thread_id_t thread_get_id(void);
-extern int thread_usleep(useconds_t);
-extern unsigned int thread_sleep(unsigned int);
+extern void thread_usleep(usec_t);
+extern void thread_sleep(sec_t);
 
 #endif

uspace/lib/c/generic/rndgen.c

@@ -52 +52 @@
 {
         rndgen_t *rndgen;
-        struct timeval tv;
+        struct timespec ts;
 
         rndgen = calloc(1, sizeof(rndgen_t));
@@ -59 +59 @@
 
         /* XXX This is a rather poor way of generating random numbers */
-        gettimeofday(&tv, NULL);
-        rndgen->seed = tv.tv_sec ^ tv.tv_usec;
+        getuptime(&ts);
+        rndgen->seed = ts.tv_sec ^ ts.tv_nsec;
 
         *rrndgen = rndgen;

uspace/lib/c/generic/stdlib.c

@@ -37 +37 @@
 #include <fibril_synch.h>
 #include <stdlib.h>
+#include <errno.h>
 #include "private/libc.h"
 #include "private/scanf.h"

uspace/lib/c/generic/thread/fibril.c

@@ -60 +60 @@
 typedef struct {
         link_t link;
-        struct timeval expires;
+        struct timespec expires;
         fibril_event_t *event;
 } _timeout_t;
@@ -142 +142 @@
 }
 
-static inline errno_t _ready_down(const struct timeval *expires)
+static inline errno_t _ready_down(const struct timespec *expires)
 {
         if (multithreaded)
@@ -253 +253 @@
 }
 
-static errno_t _ipc_wait(ipc_call_t *call, const struct timeval *expires)
+static errno_t _ipc_wait(ipc_call_t *call, const struct timespec *expires)
 {
         if (!expires)
@@ -261 +261 @@
                 return ipc_wait(call, SYNCH_NO_TIMEOUT, SYNCH_FLAGS_NON_BLOCKING);
 
-        struct timeval now;
+        struct timespec now;
         getuptime(&now);
 
-        if (tv_gteq(&now, expires))
+        if (ts_gteq(&now, expires))
                 return ipc_wait(call, SYNCH_NO_TIMEOUT, SYNCH_FLAGS_NON_BLOCKING);
 
-        return ipc_wait(call, tv_sub_diff(expires, &now), SYNCH_FLAGS_NONE);
+        return ipc_wait(call, NSEC2USEC(ts_sub_diff(expires, &now)),
+            SYNCH_FLAGS_NONE);
 }
 
@@ -275 +276 @@
  * wait after new ready fibrils are added.
  */
-static fibril_t *_ready_list_pop(const struct timeval *expires, bool locked)
+static fibril_t *_ready_list_pop(const struct timespec *expires, bool locked)
 {
         if (locked) {
@@ -370 +371 @@
 static fibril_t *_ready_list_pop_nonblocking(bool locked)
 {
-        struct timeval tv = { .tv_sec = 0, .tv_usec = 0 };
+        struct timespec tv = { .tv_sec = 0, .tv_nsec = 0 };
         return _ready_list_pop(&tv, locked);
 }
@@ -393 +394 @@
 
 /* Blocks the current fibril until an IPC call arrives. */
-static errno_t _wait_ipc(ipc_call_t *call, const struct timeval *expires)
+static errno_t _wait_ipc(ipc_call_t *call, const struct timespec *expires)
 {
         futex_assert_is_not_locked(&fibril_futex);
@@ -430 +431 @@
 
 /** Fire all timeouts that expired. */
-static struct timeval *_handle_expired_timeouts(struct timeval *next_timeout)
-{
-        struct timeval tv;
-        getuptime(&tv);
+static struct timespec *_handle_expired_timeouts(struct timespec *next_timeout)
+{
+        struct timespec ts;
+        getuptime(&ts);
 
         futex_lock(&fibril_futex);
@@ -441 +442 @@
                 _timeout_t *to = list_get_instance(cur, _timeout_t, link);
 
-                if (tv_gt(&to->expires, &tv)) {
+                if (ts_gt(&to->expires, &ts)) {
                         *next_timeout = to->expires;
                         futex_unlock(&fibril_futex);
@@ -535 +536 @@
         (void) arg;
 
-        struct timeval next_timeout;
+        struct timespec next_timeout;
         while (true) {
-                struct timeval *to = _handle_expired_timeouts(&next_timeout);
+                struct timespec *to = _handle_expired_timeouts(&next_timeout);
                 fibril_t *f = _ready_list_pop(to, false);
                 if (f) {
@@ -615 +616 @@
                 _timeout_t *cur = list_get_instance(tmp, _timeout_t, link);
 
-                if (tv_gteq(&cur->expires, &timeout->expires))
+                if (ts_gteq(&cur->expires, &timeout->expires))
                         break;
 
@@ -634 +635 @@
  * @return ETIMEOUT if timed out. EOK otherwise.
  */
-errno_t fibril_wait_timeout(fibril_event_t *event, const struct timeval *expires)
+errno_t fibril_wait_timeout(fibril_event_t *event,
+    const struct timespec *expires)
 {
         assert(fibril_self()->rmutex_locks == 0);
@@ -889 +891 @@
 }
 
-void fibril_usleep(suseconds_t timeout)
-{
-        struct timeval expires;
+void fibril_usleep(usec_t timeout)
+{
+        struct timespec expires;
         getuptime(&expires);
-        tv_add_diff(&expires, timeout);
+        ts_add_diff(&expires, USEC2NSEC(timeout));
 
         fibril_event_t event = FIBRIL_EVENT_INIT;
@@ -899 +901 @@
 }
 
-void fibril_sleep(unsigned int sec)
-{
-        struct timeval expires;
+void fibril_sleep(sec_t sec)
+{
+        struct timespec expires;
         getuptime(&expires);
         expires.tv_sec += sec;
@@ -916 +918 @@
 }
 
-errno_t fibril_ipc_wait(ipc_call_t *call, const struct timeval *expires)
+errno_t fibril_ipc_wait(ipc_call_t *call, const struct timespec *expires)
 {
         return _wait_ipc(call, expires);

uspace/lib/c/generic/thread/fibril_synch.c

@@ -37 +37 @@
 #include <async.h>
 #include <adt/list.h>
-#include <sys/time.h>
+#include <time.h>
 #include <errno.h>
 #include <assert.h>
@@ -390 +390 @@
 errno_t
 fibril_condvar_wait_timeout(fibril_condvar_t *fcv, fibril_mutex_t *fm,
-    suseconds_t timeout)
+    usec_t timeout)
 {
         assert(fibril_mutex_is_locked(fm));
@@ -400 +400 @@
         wdata.mutex = fm;
 
-        struct timeval tv;
-        struct timeval *expires = NULL;
+        struct timespec ts;
+        struct timespec *expires = NULL;
         if (timeout) {
-                getuptime(&tv);
-                tv_add_diff(&tv, timeout);
-                expires = &tv;
+                getuptime(&ts);
+                ts_add_diff(&ts, USEC2NSEC(timeout));
+                expires = &ts;
         }
 
@@ -557 +557 @@
  * @param arg           Argument for @a fun
  */
-void fibril_timer_set(fibril_timer_t *timer, suseconds_t delay,
+void fibril_timer_set(fibril_timer_t *timer, usec_t delay,
     fibril_timer_fun_t fun, void *arg)
 {
@@ -575 +575 @@
  * @param arg           Argument for @a fun
  */
-void fibril_timer_set_locked(fibril_timer_t *timer, suseconds_t delay,
+void fibril_timer_set_locked(fibril_timer_t *timer, usec_t delay,
     fibril_timer_fun_t fun, void *arg)
 {
@@ -728 +728 @@
 }
 
-errno_t fibril_semaphore_down_timeout(fibril_semaphore_t *sem, suseconds_t timeout)
+errno_t fibril_semaphore_down_timeout(fibril_semaphore_t *sem, usec_t timeout)
 {
         if (timeout < 0)
@@ -751 +751 @@
         futex_unlock(&fibril_synch_futex);
 
-        struct timeval tv;
-        struct timeval *expires = NULL;
+        struct timespec ts;
+        struct timespec *expires = NULL;
         if (timeout) {
-                getuptime(&tv);
-                tv_add_diff(&tv, timeout);
-                expires = &tv;
+                getuptime(&ts);
+                ts_add_diff(&ts, USEC2NSEC(timeout));
+                expires = &ts;
         }
 

uspace/lib/c/generic/thread/mpsc.c

@@ -146 +146 @@
  * there is no message left in the queue.
  */
-errno_t mpsc_receive(mpsc_t *q, void *b, const struct timeval *expires)
+errno_t mpsc_receive(mpsc_t *q, void *b, const struct timespec *expires)
 {
         mpsc_node_t *n;

uspace/lib/c/generic/thread/thread.c

@@ -176 +176 @@
  *
  */
-int thread_usleep(useconds_t usec)
+void thread_usleep(usec_t usec)
 {
         (void) __SYSCALL1(SYS_THREAD_USLEEP, usec);
-        return 0;
 }
 
@@ -185 +184 @@
  *
  */
-unsigned int thread_sleep(unsigned int sec)
+void thread_sleep(sec_t sec)
 {
         /*
-         * Sleep in 1000 second steps to support
-         * full argument range
+         * Sleep in 1000 second steps to support full argument range
          */
-
         while (sec > 0) {
                 unsigned int period = (sec > 1000) ? 1000 : sec;
 
-                thread_usleep(period * 1000000);
+                thread_usleep(SEC2USEC(period));
                 sec -= period;
         }
-
-        return 0;
 }
 

uspace/lib/c/generic/time.c

@@ -35 +35 @@
  */
 
-#include <sys/time.h>
 #include <time.h>
 #include <stdbool.h>
@@ -51 +50 @@
 #include <loc.h>
 #include <device/clock_dev.h>
+#include <stats.h>
 
 #define ASCTIME_BUF_LEN  26
@@ -57 +57 @@
 #define MINS_PER_HOUR  60
 #define SECS_PER_MIN   60
-#define USECS_PER_SEC  1000000
+#define NSECS_PER_SEC  1000000000ll
 #define MINS_PER_DAY   (MINS_PER_HOUR * HOURS_PER_DAY)
 #define SECS_PER_HOUR  (SECS_PER_MIN * MINS_PER_HOUR)
@@ -71 +71 @@
 static async_sess_t *clock_conn = NULL;
 
+/**
+ * Get CPU time used since the process invocation.
+ *
+ * @return Consumed microseconds by this process or -1 if not available.
+ */
+clock_t clock(void)
+{
+        static_assert(CLOCKS_PER_SEC == 1000000);
+
+        size_t count;
+        stats_cpu_t *cpu_stats = stats_get_cpus(&count);
+        if (!cpu_stats)
+                return (clock_t) -1;
+        if (!cpu_stats->frequency_mhz) {
+                free(cpu_stats);
+                return (clock_t) -1;
+        }
+
+        clock_t total_usecs = -1;
+        if (cpu_stats) {
+                stats_task_t *task_stats = stats_get_task(task_get_id());
+                if (task_stats) {
+                        total_usecs = (clock_t) (task_stats->kcycles +
+                            task_stats->ucycles) / cpu_stats->frequency_mhz;
+                        free(task_stats);
+                }
+                free(cpu_stats);
+        }
+
+        return total_usecs;
+}
+
 /** Check whether the year is a leap year.
  *
@@ -252 +284 @@
  *
  * @param tm Broken-down time to normalize.
- * @param tv Timeval to add.
+ * @param ts Timespec to add.
  *
  * @return 0 on success, -1 on overflow
  *
  */
-static int normalize_tm_tv(struct tm *tm, const struct timeval *tv)
+static int normalize_tm_ts(struct tm *tm, const struct timespec *ts)
 {
         // TODO: DST correction
 
         /* Set initial values. */
-        time_t usec = tm->tm_usec + tv->tv_usec;
-        time_t sec = tm->tm_sec + tv->tv_sec;
+        time_t nsec = tm->tm_nsec + ts->tv_nsec;
+        time_t sec = tm->tm_sec + ts->tv_sec;
         time_t min = tm->tm_min;
         time_t hour = tm->tm_hour;
@@ -271 +303 @@
 
         /* Adjust time. */
-        sec += floor_div(usec, USECS_PER_SEC);
-        usec = floor_mod(usec, USECS_PER_SEC);
+        sec += floor_div(nsec, NSECS_PER_SEC);
+        nsec = floor_mod(nsec, NSECS_PER_SEC);
         min += floor_div(sec, SECS_PER_MIN);
         sec = floor_mod(sec, SECS_PER_MIN);
@@ -321 +353 @@
 
         /* And put the values back to the struct. */
-        tm->tm_usec = (int) usec;
+        tm->tm_nsec = (int) nsec;
         tm->tm_sec = (int) sec;
         tm->tm_min = (int) min;
@@ -340 +372 @@
 static int normalize_tm_time(struct tm *tm, time_t time)
 {
-        struct timeval tv = {
+        struct timespec ts = {
                 .tv_sec = time,
-                .tv_usec = 0
+                .tv_nsec = 0
         };
 
-        return normalize_tm_tv(tm, &tv);
+        return normalize_tm_ts(tm, &ts);
 }
 
@@ -456 +488 @@
 }
 
-static void tv_normalize(struct timeval *tv)
-{
-        while (tv->tv_usec > USECS_PER_SEC) {
-                tv->tv_sec++;
-                tv->tv_usec -= USECS_PER_SEC;
-        }
-        while (tv->tv_usec < 0) {
-                tv->tv_sec--;
-                tv->tv_usec += USECS_PER_SEC;
-        }
-}
-
-/** Add microseconds to given timeval.
- *
- * @param tv    Destination timeval.
- * @param usecs Number of microseconds to add.
- *
- */
-void tv_add_diff(struct timeval *tv, suseconds_t usecs)
-{
-        tv->tv_sec += usecs / USECS_PER_SEC;
-        tv->tv_usec += usecs % USECS_PER_SEC;
-        tv_normalize(tv);
-}
-
-/** Add two timevals.
- *
- * @param tv1 First timeval.
- * @param tv2 Second timeval.
- */
-void tv_add(struct timeval *tv1, const struct timeval *tv2)
-{
-        tv1->tv_sec += tv2->tv_sec;
-        tv1->tv_usec += tv2->tv_usec;
-        tv_normalize(tv1);
-}
-
-/** Subtract two timevals.
- *
- * @param tv1 First timeval.
- * @param tv2 Second timeval.
- *
- * @return Difference between tv1 and tv2 (tv1 - tv2) in
- *         microseconds.
- *
- */
-suseconds_t tv_sub_diff(const struct timeval *tv1, const struct timeval *tv2)
-{
-        return (tv1->tv_usec - tv2->tv_usec) +
-            ((tv1->tv_sec - tv2->tv_sec) * USECS_PER_SEC);
-}
-
-/** Subtract two timevals.
- *
- * @param tv1 First timeval.
- * @param tv2 Second timeval.
- *
- */
-void tv_sub(struct timeval *tv1, const struct timeval *tv2)
-{
-        tv1->tv_sec -= tv2->tv_sec;
-        tv1->tv_usec -= tv2->tv_usec;
-        tv_normalize(tv1);
-}
-
-/** Decide if one timeval is greater than the other.
- *
- * @param t1 First timeval.
- * @param t2 Second timeval.
- *
- * @return True if tv1 is greater than tv2.
- * @return False otherwise.
- *
- */
-int tv_gt(const struct timeval *tv1, const struct timeval *tv2)
-{
-        if (tv1->tv_sec > tv2->tv_sec)
+static void ts_normalize(struct timespec *ts)
+{
+        while (ts->tv_nsec >= NSECS_PER_SEC) {
+                ts->tv_sec++;
+                ts->tv_nsec -= NSECS_PER_SEC;
+        }
+        while (ts->tv_nsec < 0) {
+                ts->tv_sec--;
+                ts->tv_nsec += NSECS_PER_SEC;
+        }
+}
+
+/** Add nanoseconds to given timespec.
+ *
+ * @param ts     Destination timespec.
+ * @param nsecs  Number of nanoseconds to add.
+ *
+ */
+void ts_add_diff(struct timespec *ts, nsec_t nsecs)
+{
+        ts->tv_sec += nsecs / NSECS_PER_SEC;
+        ts->tv_nsec += nsecs % NSECS_PER_SEC;
+        ts_normalize(ts);
+}
+
+/** Add two timespecs.
+ *
+ * @param ts1  First timespec.
+ * @param ts2  Second timespec.
+ */
+void ts_add(struct timespec *ts1, const struct timespec *ts2)
+{
+        ts1->tv_sec += ts2->tv_sec;
+        ts1->tv_nsec += ts2->tv_nsec;
+        ts_normalize(ts1);
+}
+
+/** Subtract two timespecs.
+ *
+ * @param ts1  First timespec.
+ * @param ts2  Second timespec.
+ *
+ * @return  Difference between ts1 and ts2 (ts1 - ts2) in nanoseconds.
+ *
+ */
+nsec_t ts_sub_diff(const struct timespec *ts1, const struct timespec *ts2)
+{
+        return (nsec_t) (ts1->tv_nsec - ts2->tv_nsec) +
+            SEC2NSEC((ts1->tv_sec - ts2->tv_sec));
+}
+
+/** Subtract two timespecs.
+ *
+ * @param ts1  First timespec.
+ * @param ts2  Second timespec.
+ *
+ */
+void ts_sub(struct timespec *ts1, const struct timespec *ts2)
+{
+        ts1->tv_sec -= ts2->tv_sec;
+        ts1->tv_nsec -= ts2->tv_nsec;
+        ts_normalize(ts1);
+}
+
+/** Decide if one timespec is greater than the other.
+ *
+ * @param ts1  First timespec.
+ * @param ts2  Second timespec.
+ *
+ * @return  True if ts1 is greater than ts2.
+ * @return  False otherwise.
+ *
+ */
+bool ts_gt(const struct timespec *ts1, const struct timespec *ts2)
+{
+        if (ts1->tv_sec > ts2->tv_sec)
                 return true;
 
-        if ((tv1->tv_sec == tv2->tv_sec) && (tv1->tv_usec > tv2->tv_usec))
+        if ((ts1->tv_sec == ts2->tv_sec) && (ts1->tv_nsec > ts2->tv_nsec))
                 return true;
 
@@ -541 +572 @@
 }
 
-/** Decide if one timeval is greater than or equal to the other.
- *
- * @param tv1 First timeval.
- * @param tv2 Second timeval.
- *
- * @return True if tv1 is greater than or equal to tv2.
- * @return False otherwise.
- *
- */
-int tv_gteq(const struct timeval *tv1, const struct timeval *tv2)
-{
-        if (tv1->tv_sec > tv2->tv_sec)
+/** Decide if one timespec is greater than or equal to the other.
+ *
+ * @param ts1  First timespec.
+ * @param ts2  Second timespec.
+ *
+ * @return  True if ts1 is greater than or equal to ts2.
+ * @return  False otherwise.
+ *
+ */
+bool ts_gteq(const struct timespec *ts1, const struct timespec *ts2)
+{
+        if (ts1->tv_sec > ts2->tv_sec)
                 return true;
 
-        if ((tv1->tv_sec == tv2->tv_sec) && (tv1->tv_usec >= tv2->tv_usec))
+        if ((ts1->tv_sec == ts2->tv_sec) && (ts1->tv_nsec >= ts2->tv_nsec))
                 return true;
 
@@ -561 +592 @@
 }
 
-/** Get time of day.
- *
- * The time variables are memory mapped (read-only) from kernel which
- * updates them periodically.
- *
- * As it is impossible to read 2 values atomically, we use a trick:
- * First we read the seconds, then we read the microseconds, then we
- * read the seconds again. If a second elapsed in the meantime, set
- * the microseconds to zero.
- *
- * This assures that the values returned by two subsequent calls
- * to gettimeofday() are monotonous.
- *
- */
-void gettimeofday(struct timeval *tv, struct timezone *tz)
-{
-        if (tz) {
-                tz->tz_minuteswest = 0;
-                tz->tz_dsttime = DST_NONE;
-        }
-
+/** Get real time from a RTC service.
+ *
+ * @param[out] ts  Timespec to hold time read from the RTC service (if
+ *                 available). If no such service exists, the returned time
+ *                 corresponds to system uptime.
+ */
+void getrealtime(struct timespec *ts)
+{
         if (clock_conn == NULL) {
                 category_id_t cat_id;
@@ -620 +638 @@
                 goto fallback;
 
-        tv->tv_usec = time.tm_usec;
-        tv->tv_sec = mktime(&time);
+        ts->tv_nsec = time.tm_nsec;
+        ts->tv_sec = mktime(&time);
 
         return;
 
 fallback:
-        getuptime(tv);
-}
-
-void getuptime(struct timeval *tv)
+        getuptime(ts);
+}
+
+/** Get system uptime.
+ *
+ * @param[out] ts  Timespec to hold time current uptime.
+ *
+ * The time variables are memory mapped (read-only) from kernel which
+ * updates them periodically.
+ *
+ * As it is impossible to read 2 values atomically, we use a trick:
+ * First we read the seconds, then we read the microseconds, then we
+ * read the seconds again. If a second elapsed in the meantime, set
+ * the microseconds to zero.
+ *
+ * This assures that the values returned by two subsequent calls
+ * to getuptime() are monotonous.
+ *
+ */
+void getuptime(struct timespec *ts)
 {
         if (ktime == NULL) {
@@ -654 +688 @@
 
         read_barrier();
-        tv->tv_usec = ktime->useconds;
+        ts->tv_nsec = USEC2NSEC(ktime->useconds);
 
         read_barrier();
@@ -660 +694 @@
 
         if (s1 != s2) {
-                tv->tv_sec = max(s1, s2);
-                tv->tv_usec = 0;
+                ts->tv_sec = max(s1, s2);
+                ts->tv_nsec = 0;
         } else
-                tv->tv_sec = s1;
+                ts->tv_sec = s1;
 
         return;
 
 fallback:
-        tv->tv_sec = 0;
-        tv->tv_usec = 0;
+        ts->tv_sec = 0;
+        ts->tv_nsec = 0;
 }
 
 time_t time(time_t *tloc)
 {
-        struct timeval tv;
-        gettimeofday(&tv, NULL);
+        struct timespec ts;
+        getrealtime(&ts);
 
         if (tloc)
-                *tloc = tv.tv_sec;
-
-        return tv.tv_sec;
-}
-
-void udelay(useconds_t time)
+                *tloc = ts.tv_sec;
+
+        return ts.tv_sec;
+}
+
+void udelay(sysarg_t time)
 {
         (void) __SYSCALL1(SYS_THREAD_UDELAY, (sysarg_t) time);
@@ -884 +918 @@
                         break;
                 case 's':
-                        APPEND("%ld", secs_since_epoch(tm));
+                        APPEND("%lld", secs_since_epoch(tm));
                         break;
                 case 'S':
@@ -961 +995 @@
 
         /* Set result to epoch. */
-        result->tm_usec = 0;
+        result->tm_nsec = 0;
         result->tm_sec = 0;
         result->tm_min = 0;
@@ -1038 +1072 @@
  *
  */
-errno_t time_tv2tm(const struct timeval *tv, struct tm *restrict result)
+errno_t time_ts2tm(const struct timespec *ts, struct tm *restrict result)
 {
         // TODO: Deal with timezones.
@@ -1044 +1078 @@
 
         /* Set result to epoch. */
-        result->tm_usec = 0;
+        result->tm_nsec = 0;
         result->tm_sec = 0;
         result->tm_min = 0;
@@ -1052 +1086 @@
         result->tm_year = 70; /* 1970 */
 
-        if (normalize_tm_tv(result, tv) == -1)
+        if (normalize_tm_ts(result, ts) == -1)
                 return EOVERFLOW;
 
@@ -1070 +1104 @@
 errno_t time_local2tm(const time_t time, struct tm *restrict result)
 {
-        struct timeval tv = {
+        struct timespec ts = {
                 .tv_sec = time,
-                .tv_usec = 0
+                .tv_nsec = 0
         };
 
-        return time_tv2tm(&tv, result);
+        return time_ts2tm(&ts, result);
 }
 

uspace/lib/c/include/async.h

@@ -42 +42 @@
 #include <ipc/common.h>
 #include <fibril.h>
-#include <sys/time.h>
+#include <time.h>
 #include <stdbool.h>
 #include <abi/proc/task.h>
@@ -112 +112 @@
         async_get_call_timeout(data, 0)
 
-extern bool async_get_call_timeout(ipc_call_t *, suseconds_t);
+extern bool async_get_call_timeout(ipc_call_t *, usec_t);
 
 /*
@@ -140 +140 @@
 
 extern void async_wait_for(aid_t, errno_t *);
-extern errno_t async_wait_timeout(aid_t, errno_t *, suseconds_t);
+extern errno_t async_wait_timeout(aid_t, errno_t *, usec_t);
 extern void async_forget(aid_t);
 

uspace/lib/c/include/ddi.h

@@ -39 +39 @@
 #include <stddef.h>
 #include <stdint.h>
-#include <sys/time.h>
+#include <time.h>
 #include <byteorder.h>
 #include <abi/ddi/irq.h>
@@ -138 +138 @@
 
 static inline uint8_t pio_change_8(ioport8_t *reg, uint8_t val, uint8_t mask,
-    useconds_t delay)
+    usec_t delay)
 {
         uint8_t v = pio_read_8(reg);
@@ -147 +147 @@
 
 static inline uint16_t pio_change_16(ioport16_t *reg, uint16_t val,
-    uint16_t mask, useconds_t delay)
+    uint16_t mask, usec_t delay)
 {
         uint16_t v = pio_read_16(reg);
@@ -156 +156 @@
 
 static inline uint32_t pio_change_32(ioport32_t *reg, uint32_t val,
-    uint32_t mask, useconds_t delay)
+    uint32_t mask, usec_t delay)
 {
         uint32_t v = pio_read_32(reg);
@@ -165 +165 @@
 
 static inline uint64_t pio_change_64(ioport64_t *reg, uint64_t val,
-    uint64_t mask, useconds_t delay)
+    uint64_t mask, usec_t delay)
 {
         uint64_t v = pio_read_64(reg);
@@ -173 +173 @@
 }
 
-static inline uint8_t pio_set_8(ioport8_t *r, uint8_t v, useconds_t d)
+static inline uint8_t pio_set_8(ioport8_t *r, uint8_t v, usec_t d)
 {
         return pio_change_8(r, v, 0, d);
 }
-static inline uint16_t pio_set_16(ioport16_t *r, uint16_t v, useconds_t d)
+static inline uint16_t pio_set_16(ioport16_t *r, uint16_t v, usec_t d)
 {
         return pio_change_16(r, v, 0, d);
 }
-static inline uint32_t pio_set_32(ioport32_t *r, uint32_t v, useconds_t d)
+static inline uint32_t pio_set_32(ioport32_t *r, uint32_t v, usec_t d)
 {
         return pio_change_32(r, v, 0, d);
 }
-static inline uint64_t pio_set_64(ioport64_t *r, uint64_t v, useconds_t d)
+static inline uint64_t pio_set_64(ioport64_t *r, uint64_t v, usec_t d)
 {
         return pio_change_64(r, v, 0, d);
 }
 
-static inline uint8_t pio_clear_8(ioport8_t *r, uint8_t v, useconds_t d)
+static inline uint8_t pio_clear_8(ioport8_t *r, uint8_t v, usec_t d)
 {
         return pio_change_8(r, 0, v, d);
 }
-static inline uint16_t pio_clear_16(ioport16_t *r, uint16_t v, useconds_t d)
+static inline uint16_t pio_clear_16(ioport16_t *r, uint16_t v, usec_t d)
 {
         return pio_change_16(r, 0, v, d);
 }
-static inline uint32_t pio_clear_32(ioport32_t *r, uint32_t v, useconds_t d)
+static inline uint32_t pio_clear_32(ioport32_t *r, uint32_t v, usec_t d)
 {
         return pio_change_32(r, 0, v, d);
 }
-static inline uint64_t pio_clear_64(ioport64_t *r, uint64_t v, useconds_t d)
+static inline uint64_t pio_clear_64(ioport64_t *r, uint64_t v, usec_t d)
 {
         return pio_change_64(r, 0, v, d);

uspace/lib/c/include/fibril.h

@@ -60 +60 @@
 extern void fibril_yield(void);
 
-extern void fibril_usleep(suseconds_t);
-extern void fibril_sleep(unsigned int);
+extern void fibril_usleep(usec_t);
+extern void fibril_sleep(sec_t);
 
 extern void fibril_enable_multithreaded(void);

uspace/lib/c/include/fibril_synch.h

@@ -39 +39 @@
 #include <adt/list.h>
 #include <tls.h>
-#include <sys/time.h>
+#include <time.h>
 #include <stdbool.h>
 
@@ -138 +138 @@
         fid_t handler_fid;
 
-        suseconds_t delay;
+        usec_t delay;
         fibril_timer_fun_t fun;
         void *arg;
@@ -181 +181 @@
 extern void fibril_condvar_initialize(fibril_condvar_t *);
 extern errno_t fibril_condvar_wait_timeout(fibril_condvar_t *, fibril_mutex_t *,
-    suseconds_t);
+    usec_t);
 extern void fibril_condvar_wait(fibril_condvar_t *, fibril_mutex_t *);
 extern void fibril_condvar_signal(fibril_condvar_t *);
@@ -188 +188 @@
 extern fibril_timer_t *fibril_timer_create(fibril_mutex_t *);
 extern void fibril_timer_destroy(fibril_timer_t *);
-extern void fibril_timer_set(fibril_timer_t *, suseconds_t, fibril_timer_fun_t,
+extern void fibril_timer_set(fibril_timer_t *, usec_t, fibril_timer_fun_t,
     void *);
-extern void fibril_timer_set_locked(fibril_timer_t *, suseconds_t,
+extern void fibril_timer_set_locked(fibril_timer_t *, usec_t,
     fibril_timer_fun_t, void *);
 extern fibril_timer_state_t fibril_timer_clear(fibril_timer_t *);
@@ -198 +198 @@
 extern void fibril_semaphore_up(fibril_semaphore_t *);
 extern void fibril_semaphore_down(fibril_semaphore_t *);
-extern errno_t fibril_semaphore_down_timeout(fibril_semaphore_t *, suseconds_t);
+extern errno_t fibril_semaphore_down_timeout(fibril_semaphore_t *, usec_t);
 extern void fibril_semaphore_close(fibril_semaphore_t *);
 
@@ -205 +205 @@
 extern void mpsc_destroy(mpsc_t *);
 extern errno_t mpsc_send(mpsc_t *, const void *);
-extern errno_t mpsc_receive(mpsc_t *, void *, const struct timeval *);
+extern errno_t mpsc_receive(mpsc_t *, void *, const struct timespec *);
 extern void mpsc_close(mpsc_t *);
 

uspace/lib/c/include/io/con_srv.h

@@ -45 +45 @@
 #include <io/style.h>
 #include <stdbool.h>
-#include <sys/time.h>
+#include <time.h>
 #include <stddef.h>
 
@@ -55 +55 @@
         void *sarg;
         /** Period to check for abort */
-        suseconds_t abort_timeout;
+        usec_t abort_timeout;
         bool aborted;
 } con_srvs_t;

uspace/lib/c/include/io/console.h

@@ -36 +36 @@
 #define LIBC_IO_CONSOLE_H_
 
-#include <sys/time.h>
+#include <time.h>
 #include <io/concaps.h>
 #include <io/kbd_event.h>
@@ -85 +85 @@
 extern bool console_get_event(console_ctrl_t *, cons_event_t *);
 extern bool console_get_event_timeout(console_ctrl_t *, cons_event_t *,
-    suseconds_t *);
+    usec_t *);
 
 #endif

uspace/lib/c/include/time.h

@@ -1 +1 @@
 /*
- * Copyright (c) 2007 Jakub Jermar
+ * Copyright (c) 2018 Jakub Jermar
  * All rights reserved.
  *
@@ -40 +40 @@
 #endif
 
-#include <sys/time.h>
 
+/* ISO/IEC 9899:2011 7.27.1 (2) */
+
+#include <_bits/NULL.h>
+
+#define CLOCKS_PER_SEC  ((clock_t) 1000000)
+
+#define TIME_UTC        1
+
+
+/* ISO/IEC 9899:2011 7.27.1 (3) */
+
+#include <_bits/size_t.h>
+
+/* ISO/IEC 9899:2011 7.27.1 (3), (4) */
+
+typedef long long time_t;
+typedef long long clock_t;
+
+struct timespec {
+        time_t tv_sec;
+        long tv_nsec;
+};
+
+struct tm {
+        int tm_sec;
+        int tm_nsec;
+        int tm_min;
+        int tm_hour;
+        int tm_mday;
+        int tm_mon;
+        int tm_year;
+        int tm_wday;
+        int tm_yday;
+        int tm_isdst;
+};
+
+/* ISO/IEC 9899:2011 7.27.2.1 (1) */
+extern clock_t clock(void);
+
+/* ISO/IEC 9899:2011 7.27.2.2 (1) */
+extern double difftime(time_t, time_t);
+
+/* ISO/IEC 9899:2011 7.27.2.3 (1) */
+extern time_t mktime(struct tm *);
+
+/* ISO/IEC 9899:2011 7.27.2.4 (1) */
 extern time_t time(time_t *);
+
+/* ISO/IEC 9899:2011 7.27.2.5 (1) */
+extern int timespec_get(struct timespec *, int);
+
+/* ISO/IEC 9899:2011 7.27.3.1 (1) */
+extern char *asctime(const struct tm *);
+
+/* ISO/IEC 9899:2011 7.27.3.2 (1) */
+extern char *ctime(const time_t *);
+
+/* ISO/IEC 9899:2011 7.27.3.3 (1) */
+extern struct tm *gmtime(const time_t *);
+
+/* ISO/IEC 9899:2011 7.27.3.4 (1) */
+extern struct tm *localtime(const time_t *);
+
+/* ISO/IEC 9899:2011 7.27.3.5 (1) */
+extern size_t strftime(char *, size_t, const char *, const struct tm *);
+
+/*
+ * HelenOS specific extensions
+ */
+
+#include <stdbool.h>
+#include <_bits/errno.h>
+
+typedef long long sec_t;
+typedef long long msec_t;
+typedef long long usec_t;
+typedef long long nsec_t;       /* good for +/- 292 years */
+
+#define SEC2MSEC(s)     ((s) * 1000ll)
+#define SEC2USEC(s)     ((s) * 1000000ll)
+#define SEC2NSEC(s)     ((s) * 1000000000ll)
+
+#define MSEC2SEC(ms)    ((ms) / 1000ll)
+#define MSEC2USEC(ms)   ((ms) * 1000ll)
+#define MSEC2NSEC(ms)   ((ms) * 1000000ll)
+
+#define USEC2SEC(us)    ((us) / 1000000ll)
+#define USEC2MSEC(us)   ((us) / 1000ll)
+#define USEC2NSEC(us)   ((us) * 1000ll)
+
+#define NSEC2SEC(ns)    ((ns) / 1000000000ll)
+#define NSEC2MSEC(ns)   ((ns) / 1000000ll)
+#define NSEC2USEC(ns)   ((ns) / 1000ll)
+
+extern void getuptime(struct timespec *);
+extern void getrealtime(struct timespec *);
+
+extern void ts_add_diff(struct timespec *, nsec_t);
+extern void ts_add(struct timespec *, const struct timespec *);
+extern void ts_sub(struct timespec *, const struct timespec *);
+extern nsec_t ts_sub_diff(const struct timespec *, const struct timespec *);
+extern bool ts_gt(const struct timespec *, const struct timespec *);
+extern bool ts_gteq(const struct timespec *, const struct timespec *);
+
+extern errno_t time_utc2tm(const time_t, struct tm *);
+extern errno_t time_utc2str(const time_t, char *);
+extern void time_tm2str(const struct tm *, char *);
+extern errno_t time_ts2tm(const struct timespec *, struct tm *);
+extern errno_t time_local2tm(const time_t, struct tm *);
+extern errno_t time_local2str(const time_t, char *);
+
+extern void udelay(sysarg_t);
 
 #ifdef __cplusplus

uspace/lib/cpp/include/__bits/chrono.hpp

@@ -611 +611 @@
             static time_point now()
             {
-                hel::timeval tv{};
-                hel::gettimeofday(&tv, nullptr);
-
-                rep time = tv.tv_usec;
-                time += (tv.tv_sec * 1'000'000ul);
+                hel::timespec ts{};
+                hel::getrealtime(&ts);
+
+                rep time = NSEC2USEC(ts.tv_nsec);
+                time += (ts.tv_sec * 1'000'000ul);
 
                 return time_point{duration{time - epoch_usecs}};
@@ -654 +654 @@
             static time_point now()
             {
-                hel::timeval tv{};
-                hel::getuptime(&tv);
-
-                rep time = tv.tv_usec;
-                time += (tv.tv_sec * 1'000'000ul);
+                hel::timespec ts{};
+                hel::getuptime(&ts);
+
+                rep time = NSEC2USEC(ts.tv_nsec);
+                time += (ts.tv_sec * 1'000'000ul);
 
                 return time_point{duration{time}};

uspace/lib/cpp/include/__bits/thread/threading.hpp

@@ -58 +58 @@
         using thread_type       = hel::fid_t;
         using condvar_type      = hel::fibril_condvar_t;
-        using time_unit         = hel::suseconds_t;
+        using time_unit         = hel::usec_t;
         using shared_mutex_type = hel::fibril_rwlock_t;
 

uspace/lib/drv/generic/remote_nic.c

@@ -39 +39 @@
 #include <errno.h>
 #include <ipc/services.h>
-#include <sys/time.h>
+#include <time.h>
 #include <macros.h>
 
@@ -1262 +1262 @@
  */
 errno_t nic_poll_get_mode(async_sess_t *dev_sess, nic_poll_mode_t *mode,
-    struct timeval *period)
+    struct timespec *period)
 {
         assert(mode);
@@ -1280 +1280 @@
 
         if (period != NULL)
-                rc = async_data_read_start(exch, period, sizeof(struct timeval));
+                rc = async_data_read_start(exch, period, sizeof(struct timespec));
 
         async_exchange_end(exch);
@@ -1296 +1296 @@
  */
 errno_t nic_poll_set_mode(async_sess_t *dev_sess, nic_poll_mode_t mode,
-    const struct timeval *period)
+    const struct timespec *period)
 {
         async_exch_t *exch = async_exchange_begin(dev_sess);
@@ -1305 +1305 @@
         errno_t rc;
         if (period)
-                rc = async_data_write_start(exch, period, sizeof(struct timeval));
+                rc = async_data_write_start(exch, period, sizeof(struct timespec));
         else
                 rc = EOK;
@@ -2405 +2405 @@
         nic_poll_mode_t mode = NIC_POLL_IMMEDIATE;
         int request_data = IPC_GET_ARG2(*call);
-        struct timeval period = {
+        struct timespec period = {
                 .tv_sec = 0,
-                .tv_usec = 0
+                .tv_nsec = 0
         };
 
@@ -2421 +2421 @@
                 }
 
-                if (max_len != sizeof(struct timeval)) {
+                if (max_len != sizeof(struct timespec)) {
                         async_answer_0(&data, ELIMIT);
                         async_answer_0(call, ELIMIT);
@@ -2428 +2428 @@
 
                 async_data_read_finalize(&data, &period,
-                    sizeof(struct timeval));
+                    sizeof(struct timespec));
         }
 
@@ -2441 +2441 @@
         nic_poll_mode_t mode = IPC_GET_ARG2(*call);
         int has_period = IPC_GET_ARG3(*call);
-        struct timeval period_buf;
-        struct timeval *period = NULL;
+        struct timespec period_buf;
+        struct timespec *period = NULL;
         size_t length;
 
@@ -2453 +2453 @@
                 }
 
-                if (length != sizeof(struct timeval)) {
+                if (length != sizeof(struct timespec)) {
                         async_answer_0(&data, ELIMIT);
                         async_answer_0(call, ELIMIT);

uspace/lib/drv/include/nic_iface.h

@@ -106 +106 @@
 
 extern errno_t nic_poll_get_mode(async_sess_t *, nic_poll_mode_t *,
-    struct timeval *);
+    struct timespec *);
 extern errno_t nic_poll_set_mode(async_sess_t *, nic_poll_mode_t,
-    const struct timeval *);
+    const struct timespec *);
 extern errno_t nic_poll_now(async_sess_t *);
 

uspace/lib/drv/include/ops/nic.h

@@ -39 +39 @@
 #include <ipc/services.h>
 #include <nic/nic.h>
-#include <sys/time.h>
+#include <time.h>
 #include "../ddf/driver.h"
 
@@ -104 +104 @@
 
         errno_t (*poll_get_mode)(ddf_fun_t *, nic_poll_mode_t *,
-            struct timeval *);
+            struct timespec *);
         errno_t (*poll_set_mode)(ddf_fun_t *, nic_poll_mode_t,
-            const struct timeval *);
+            const struct timespec *);
         errno_t (*poll_now)(ddf_fun_t *);
 } nic_iface_t;

uspace/lib/drv/include/pci_dev_iface.h

@@ -37 +37 @@
 #ifndef LIBDRV_PCI_DEV_IFACE_H_
 #define LIBDRV_PCI_DEV_IFACE_H_
+
+#include <errno.h>
 
 #include "ddf/driver.h"

uspace/lib/nic/include/nic.h

@@ -196 +196 @@
  */
 typedef errno_t (*poll_mode_change_handler)(nic_t *,
-    nic_poll_mode_t, const struct timeval *);
+    nic_poll_mode_t, const struct timespec *);
 
 /**
@@ -240 +240 @@
 extern void nic_set_tx_busy(nic_t *, int);
 extern errno_t nic_report_address(nic_t *, const nic_address_t *);
-extern errno_t nic_report_poll_mode(nic_t *, nic_poll_mode_t, struct timeval *);
+extern errno_t nic_report_poll_mode(nic_t *, nic_poll_mode_t, struct timespec *);
 extern void nic_query_address(nic_t *, nic_address_t *);
 extern void nic_received_frame(nic_t *, nic_frame_t *);
 extern void nic_received_frame_list(nic_t *, nic_frame_list_t *);
-extern nic_poll_mode_t nic_query_poll_mode(nic_t *, struct timeval *);
+extern nic_poll_mode_t nic_query_poll_mode(nic_t *, struct timespec *);
 
 /* Statistics updates */

uspace/lib/nic/include/nic_driver.h

@@ -83 +83 @@
         nic_poll_mode_t poll_mode;
         /** Polling period (applicable when poll_mode == NIC_POLL_PERIODIC) */
-        struct timeval poll_period;
+        struct timespec poll_period;
         /** Current polling mode of the NIC */
         nic_poll_mode_t default_poll_mode;
         /** Polling period (applicable when default_poll_mode == NIC_POLL_PERIODIC) */
-        struct timeval default_poll_period;
+        struct timespec default_poll_period;
         /** Software period fibrill information */
         struct sw_poll_info sw_poll_info;

uspace/lib/nic/include/nic_impl.h

@@ -78 +78 @@
 extern errno_t nic_wol_virtue_get_caps_impl(ddf_fun_t *, nic_wv_type_t, int *);
 extern errno_t nic_poll_get_mode_impl(ddf_fun_t *,
-    nic_poll_mode_t *, struct timeval *);
+    nic_poll_mode_t *, struct timespec *);
 extern errno_t nic_poll_set_mode_impl(ddf_fun_t *,
-    nic_poll_mode_t, const struct timeval *);
+    nic_poll_mode_t, const struct timespec *);
 extern errno_t nic_poll_now_impl(ddf_fun_t *);
 

uspace/lib/nic/src/nic_driver.c

@@ -384 +384 @@
  *  @return Current polling mode of the controller
  */
-nic_poll_mode_t nic_query_poll_mode(nic_t *nic_data, struct timeval *period)
+nic_poll_mode_t nic_query_poll_mode(nic_t *nic_data, struct timespec *period)
 {
         if (period)
@@ -400 +400 @@
  */
 errno_t nic_report_poll_mode(nic_t *nic_data, nic_poll_mode_t mode,
-    struct timeval *period)
+    struct timespec *period)
 {
         errno_t rc = EOK;
@@ -408 +408 @@
         if (mode == NIC_POLL_PERIODIC) {
                 if (period) {
-                        memcpy(&nic_data->default_poll_period, period, sizeof(struct timeval));
-                        memcpy(&nic_data->poll_period, period, sizeof(struct timeval));
+                        memcpy(&nic_data->default_poll_period, period, sizeof(struct timespec));
+                        memcpy(&nic_data->poll_period, period, sizeof(struct timespec));
                 } else {
                         rc = EINVAL;
@@ -1030 +1030 @@
  *  @returns Nonzero if t is zero interval
  */
-static int timeval_nonpositive(struct timeval t)
-{
-        return (t.tv_sec <= 0) && (t.tv_usec <= 0);
+static int timespec_nonpositive(struct timespec t)
+{
+        return (t.tv_sec <= 0) && (t.tv_nsec <= 0);
 }
 
@@ -1051 +1051 @@
                 int run = info->run;
                 int running = info->running;
-                struct timeval remaining = nic->poll_period;
+                struct timespec remaining = nic->poll_period;
                 fibril_rwlock_read_unlock(&nic->main_lock);
 
                 if (!running) {
                         remaining.tv_sec = 5;
-                        remaining.tv_usec = 0;
+                        remaining.tv_nsec = 0;
                 }
 
                 /* Wait the period (keep attention to overflows) */
-                while (!timeval_nonpositive(remaining)) {
-                        suseconds_t wait = 0;
+                while (!timespec_nonpositive(remaining)) {
+                        usec_t wait = 0;
                         if (remaining.tv_sec > 0) {
                                 time_t wait_sec = remaining.tv_sec;
@@ -1071 +1071 @@
                                         wait_sec = 5;
 
-                                wait = (suseconds_t) wait_sec * 1000000;
+                                wait = SEC2USEC(wait_sec);
 
                                 remaining.tv_sec -= wait_sec;
                         } else {
-                                wait = remaining.tv_usec;
+                                wait = NSEC2USEC(remaining.tv_nsec);
 
                                 if (wait > 5 * 1000000) {
@@ -1081 +1081 @@
                                 }
 
-                                remaining.tv_usec -= wait;
+                                remaining.tv_nsec -= USEC2NSEC(wait);
                         }
                         fibril_usleep(wait);

uspace/lib/nic/src/nic_impl.c

@@ -121 +121 @@
                 nic_data->poll_mode = nic_data->default_poll_mode;
                 memcpy(&nic_data->poll_period, &nic_data->default_poll_period,
-                    sizeof(struct timeval));
+                    sizeof(struct timespec));
                 if (rc != EOK) {
                         /*
@@ -714 +714 @@
  */
 errno_t nic_poll_get_mode_impl(ddf_fun_t *fun,
-    nic_poll_mode_t *mode, struct timeval *period)
+    nic_poll_mode_t *mode, struct timespec *period)
 {
         nic_t *nic_data = nic_get_from_ddf_fun(fun);
         fibril_rwlock_read_lock(&nic_data->main_lock);
         *mode = nic_data->poll_mode;
-        memcpy(period, &nic_data->poll_period, sizeof(struct timeval));
+        memcpy(period, &nic_data->poll_period, sizeof(struct timespec));
         fibril_rwlock_read_unlock(&nic_data->main_lock);
         return EOK;
@@ -737 +737 @@
  */
 errno_t nic_poll_set_mode_impl(ddf_fun_t *fun,
-    nic_poll_mode_t mode, const struct timeval *period)
+    nic_poll_mode_t mode, const struct timespec *period)
 {
         nic_t *nic_data = nic_get_from_ddf_fun(fun);
@@ -753 +753 @@
                 if (period == NULL)
                         return EINVAL;
-                if (period->tv_sec == 0 && period->tv_usec == 0)
+                if (period->tv_sec == 0 && period->tv_nsec == 0)
                         return EINVAL;
-                if (period->tv_sec < 0 || period->tv_usec < 0)
+                if (period->tv_sec < 0 || period->tv_nsec < 0)
                         return EINVAL;
         }

uspace/lib/pcm/include/pcm/format.h

@@ -80 +80 @@
  * @return Number of microseconds.
  */
-static inline useconds_t pcm_format_size_to_usec(size_t size,
-    const pcm_format_t *a)
+static inline usec_t pcm_format_size_to_usec(size_t size, const pcm_format_t *a)
 {
         return pcm_sample_format_size_to_usec(size, a->sampling_rate,

uspace/lib/pcm/include/pcm/sample_format.h

@@ -167 +167 @@
  * @return Number of useconds of audio data.
  */
-static inline useconds_t pcm_sample_format_size_to_usec(size_t size,
+static inline usec_t pcm_sample_format_size_to_usec(size_t size,
     unsigned sample_rate, unsigned channels, pcm_sample_format_t format)
 {

uspace/lib/pcut/src/os/helenos.c

@@ -141 +141 @@
         pcut_item_t *test = arg;
         int timeout_sec = pcut_get_test_timeout(test);
-        suseconds_t timeout_us = (suseconds_t) timeout_sec * 1000 * 1000;
+        usec_t timeout_us = SEC2USEC(timeout_sec);
 
         fibril_mutex_lock(&forced_termination_mutex);

uspace/lib/posix/include/posix/sys/time.h

@@ -34 +34 @@
 #define POSIX_SYS_TIME_H_
 
-#include "libc/sys/time.h"
+#include "libc/time.h"
+
+struct timeval {
+        time_t tv_sec;        /* seconds */
+        suseconds_t tv_usec;  /* microseconds */
+};
+
+extern int gettimeofday(struct timeval *, void *);
 
 #endif

uspace/lib/posix/include/posix/sys/types.h

@@ -38 +38 @@
 
 #include "libc/offset.h"
-#include "libc/sys/time.h"
 #include "libc/types/common.h"
 
@@ -56 +55 @@
 
 /* Clock Types */
-typedef long clock_t;
 typedef int clockid_t;
 
+typedef long suseconds_t;
 
 #endif /* POSIX_SYS_TYPES_H_ */

uspace/lib/posix/include/posix/time.h

@@ -41 +41 @@
 #include <_bits/NULL.h>
 
-#ifndef CLOCKS_PER_SEC
-#define CLOCKS_PER_SEC (1000000L)
-#endif
+#include "libc/time.h"
 
 #ifndef __locale_t_defined
@@ -57 +55 @@
 #define CLOCK_REALTIME ((clockid_t) 0)
 
-struct timespec {
-        time_t tv_sec; /* Seconds. */
-        long tv_nsec; /* Nanoseconds. */
-};
+#define ASCTIME_BUF_LEN  26
 
 struct itimerspec {
@@ -104 +99 @@
     const struct timespec *rqtp, struct timespec *rmtp);
 
-/* CPU Time */
-extern clock_t clock(void);
-
-
 #endif  // POSIX_TIME_H_
 

uspace/lib/posix/src/internal/common.h

@@ -38 +38 @@
 #include <stdio.h>
 #include <stdlib.h>
+#include <errno.h>
 #include <offset.h>
 #include <vfs/vfs.h>

uspace/lib/posix/src/time.c

@@ -35 +35 @@
 
 #include "internal/common.h"
+#include "posix/sys/types.h"
+#include "posix/sys/time.h"
 #include "posix/time.h"
 
@@ -47 +49 @@
 #include "libc/malloc.h"
 #include "libc/task.h"
-#include "libc/stats.h"
 #include "libc/stddef.h"
-#include "libc/sys/time.h"
+#include "libc/time.h"
 
 // TODO: test everything in this file
@@ -219 +220 @@
         case CLOCK_REALTIME:
                 res->tv_sec = 0;
-                res->tv_nsec = 1000; /* Microsecond resolution. */
+                res->tv_nsec = USEC2NSEC(1); /* Microsecond resolution. */
                 return 0;
         default:
@@ -244 +245 @@
                 gettimeofday(&tv, NULL);
                 tp->tv_sec = tv.tv_sec;
-                tp->tv_nsec = tv.tv_usec * 1000;
+                tp->tv_nsec = USEC2NSEC(tv.tv_usec);
                 return 0;
         default:
@@ -300 +301 @@
                 }
                 if (rqtp->tv_nsec != 0) {
-                        fibril_usleep(rqtp->tv_nsec / 1000);
+                        fibril_usleep(NSEC2USEC(rqtp->tv_nsec));
                 }
                 return 0;
@@ -309 +310 @@
 }
 
-/**
- * Get CPU time used since the process invocation.
- *
- * @return Consumed CPU cycles by this process or -1 if not available.
- */
-clock_t clock(void)
-{
-        clock_t total_cycles = -1;
-        stats_task_t *task_stats = stats_get_task(task_get_id());
-        if (task_stats) {
-                total_cycles = (clock_t) (task_stats->kcycles +
-                    task_stats->ucycles);
-                free(task_stats);
-                task_stats = 0;
-        }
-
-        return total_cycles;
+int gettimeofday(struct timeval *tv, void *tz)
+{
+        struct timespec ts;
+
+        getrealtime(&ts);
+        tv->tv_sec = ts.tv_sec;
+        tv->tv_usec = NSEC2USEC(ts.tv_nsec);
+
+        return 0;
 }
 

uspace/lib/usb/include/usb/port.h

@@ -90 +90 @@
 
 /* And these are to be called from the connected handler. */
-int usb_port_condvar_wait_timeout(usb_port_t *port,
-    fibril_condvar_t *, suseconds_t);
+int usb_port_condvar_wait_timeout(usb_port_t *port, fibril_condvar_t *, usec_t);
 
 /**

uspace/lib/usb/src/port.c

@@ -237 +237 @@
 }
 
-int usb_port_condvar_wait_timeout(usb_port_t *port, fibril_condvar_t *cv, suseconds_t timeout)
+int usb_port_condvar_wait_timeout(usb_port_t *port, fibril_condvar_t *cv,
+    usec_t timeout)
 {
         assert(port);

uspace/lib/usbhost/include/usb/host/endpoint.h

@@ -45 +45 @@
 #include <refcount.h>
 #include <stdbool.h>
-#include <sys/time.h>
+#include <time.h>
 #include <usb/usb.h>
 #include <usb/host/bus.h>
@@ -125 +125 @@
 extern void endpoint_set_offline_locked(endpoint_t *);
 
-extern void endpoint_wait_timeout_locked(endpoint_t *ep, suseconds_t);
+extern void endpoint_wait_timeout_locked(endpoint_t *ep, usec_t);
 extern int endpoint_activate_locked(endpoint_t *, usb_transfer_batch_t *);
 extern void endpoint_deactivate_locked(endpoint_t *);

uspace/lib/usbhost/src/endpoint.c

@@ -145 +145 @@
  * offline (and is interrupted by the endpoint going offline).
  */
-void endpoint_wait_timeout_locked(endpoint_t *ep, suseconds_t timeout)
+void endpoint_wait_timeout_locked(endpoint_t *ep, usec_t timeout)
 {
         assert(ep);