sqlite: Improve boot time estimation

Our old boot time estimation algorithm has served us well, but started
to show issues when faced with faster devices than data_exporter has
normally been run on. The problem was our use of multiple clock sources,
and more specifically, reading uptime from file.

What could happen was that uptime would increase, but the clock used as
source for gettimeofday() would not. On devices with a (working) RTC or
on restarts of data exporter, this timer-behavior caused our estimate
for the real boot time to be less than the original estimate. When we
detected a clock that has moved backwards, we stop exporting metadata.

This commit improves how we make the estimations by reducing the number
of clock sources. Uptime is only read when we estimate the original boot
time, and then we use CLOCK_MONOTONIC_RAW to estimate the amount of time
that has passed when we estimate the real boot time. Instead of using
gettimeofday() to read the current wall time, we use clock_gettime().

Using clock_gettime() ensures that the real time as well as elapsed time
all come from the same source. We also read the wall time after we read
MONOTONIC_RAW, to avoid the elapsed time being "larger" than the real
time. Worst-case, what can happen with the new approach, is that the
timers have not changed and the diff is 0.

Author: kristrev

metadata_writer_sqlite.c

@@ -31,9 +31,12 @@
 #include <libmnl/libmnl.h>
 #include <string.h>
 #include <sys/time.h>
+#include <time.h>
 #include <stdlib.h>
 #include <errno.h>
 #include <sqlite3.h>
+#include <linux/sysinfo.h>
+#include <sys/syscall.h>
 
 #include "metadata_writer_sqlite.h"
 #include "metadata_writer_inventory_conn.h"
@@ -295,27 +298,51 @@ static sqlite3* md_sqlite_configure_db(struct md_writer_sqlite *mws, const char
     return db_handle;
 }
 
-static int md_sqlite_read_boot_time(struct md_writer_sqlite *mws, uint64_t *boot_time)
+static int md_sqlite_read_orig_boot_time(struct md_writer_sqlite *mws)
 {
-    struct timeval tv;
-    uint64_t uptime;
+    struct timespec tp_raw, tp_real;
+    struct sysinfo info = {0};
 
-    //read uptime
-    if (system_helpers_read_uint64_from_file("/proc/uptime", &uptime)) {
-        return RETVAL_FAILURE;
-    }
+    syscall(SYS_sysinfo, &info);
 
-    gettimeofday(&tv, NULL);
+    clock_gettime(CLOCK_MONOTONIC_RAW, &tp_raw);
+    clock_gettime(CLOCK_REALTIME, &tp_real);
 
-    *boot_time = tv.tv_sec - uptime;
-    
-    if (*boot_time < mws->orig_boot_time) {
-        return RETVAL_FAILURE;
+    //This can only happen on boot on devices where time is reset to epoch.
+    //uptime and clock_gettime() come from different clock sources, uptime might
+    //for example have been updated before tp_real
+    if (info.uptime > tp_real.tv_sec) {
+        mws->orig_boot_time = 0;
+    } else {
+        mws->orig_boot_time = tp_real.tv_sec - info.uptime;
     }
 
+    mws->orig_uptime = info.uptime;
+    mws->orig_raw_time = tp_raw.tv_sec;
+
     return RETVAL_SUCCESS;
 }
 
+static void md_sqlite_get_real_boot_time(struct md_writer_sqlite *mws, uint64_t *real_boot_time)
+{
+    struct timespec tp_raw, tp_real;
+
+    clock_gettime(CLOCK_MONOTONIC_RAW, &tp_raw);
+    clock_gettime(CLOCK_REALTIME, &tp_real);
+
+    //The calculation here is as follows:
+    //* The goal is to find the correct boot time, now that we have a valid NTP fix
+    //* We get the current (walltime).
+    //* From this value we want to subtract the total uptime.
+    //* To reduce the number of clock sources, we use use MONOTONIG_RAW to calculate
+    //the amount of time that has passed since data_exporter was started.
+    //* We add the diff between (cur_raw - orig_raw) to the uptime we read when
+    //data_exporter was started. The sum is time elapsed since boot.
+    //* In order to get the "correct" boot time, we subtract the calculation above
+    //from the current walltime.
+    *real_boot_time = tp_real.tv_sec - (mws->orig_uptime + (tp_raw.tv_sec - mws->orig_raw_time));
+}
+
 static int md_sqlite_configure(struct md_writer_sqlite *mws,
         const char *db_filename, uint32_t node_id, uint32_t db_interval,
         uint32_t db_events, const char *meta_prefix, const char *gps_prefix,
@@ -466,7 +493,7 @@ static int md_sqlite_configure(struct md_writer_sqlite *mws,
         system_helpers_read_uint64_from_file(mws->last_conn_tstamp_path,
                 &(mws->dump_tstamp));
 
-    return md_sqlite_read_boot_time(mws, &(mws->orig_boot_time));
+    return md_sqlite_read_orig_boot_time(mws);
 }
 
 void md_sqlite_usage()
@@ -575,13 +602,12 @@ static uint8_t md_sqlite_check_valid_tstamp(struct md_writer_sqlite *mws)
 
     gettimeofday(&tv, NULL);
 
-    if (mws->ntp_fix_file[0] && access(mws->ntp_fix_file, F_OK))
-        return RETVAL_FAILURE;
-
-    if (md_sqlite_read_boot_time(mws, &real_boot_time)) {
+    if (mws->ntp_fix_file[0] && access(mws->ntp_fix_file, F_OK)) {
         return RETVAL_FAILURE;
     }
 
+    md_sqlite_get_real_boot_time(mws, &real_boot_time);
+
     META_PRINT_SYSLOG(mws->parent, LOG_INFO, "Real boot %" PRIu64 " orig boot %" PRIu64 "\n", real_boot_time, mws->orig_boot_time);
 
     if (md_sqlite_update_timestamp_db(mws, UPDATE_EVENT_TSTAMP,

metadata_writer_sqlite.h

@@ -262,6 +262,8 @@ struct md_writer_sqlite {
     uint64_t last_msg_tstamp;
     uint64_t last_gps_insert;
     uint64_t orig_boot_time;
+    uint64_t orig_uptime;
+    uint64_t orig_raw_time;
 
     //TODO: Consider moving this to the generic writer struct if need be
     //These values keep track of the unique session id (and multiplier), which