use usec_t for microseconds time variables

Also use USEC_PER_SEC for seconds to microseconds conversions.

Signed-off-by: Rémi Lefèvre <remi.lefevre@parrot.com>

diff --git a/src/apps_plugin.c b/src/apps_plugin.c
index 0247bb90b059204cde48f6279bd5e5de153ba3a7..6431897f455a6965e9384f9f11fe33e8ad029751 100644 (file)
--- a/src/apps_plugin.c
+++ b/src/apps_plugin.c
@@ -611,35 +611,35 @@ int read_proc_pid_stat(struct pid_stat *p) {
 
     last = p->minflt_raw;
     p->minflt_raw       = strtoull(procfile_lineword(ff, 0, 9), NULL, 10);
-    p->minflt = (p->minflt_raw - last) * (1000000ULL * RATES_DETAIL) / (p->stat_collected_usec - p->last_stat_collected_usec);
+    p->minflt = (p->minflt_raw - last) * (USEC_PER_SEC * RATES_DETAIL) / (p->stat_collected_usec - p->last_stat_collected_usec);
 
     last = p->cminflt_raw;
     p->cminflt_raw      = strtoull(procfile_lineword(ff, 0, 10), NULL, 10);
-    p->cminflt = (p->cminflt_raw - last) * (1000000ULL * RATES_DETAIL) / (p->stat_collected_usec - p->last_stat_collected_usec);
+    p->cminflt = (p->cminflt_raw - last) * (USEC_PER_SEC * RATES_DETAIL) / (p->stat_collected_usec - p->last_stat_collected_usec);
 
     last = p->majflt_raw;
     p->majflt_raw       = strtoull(procfile_lineword(ff, 0, 11), NULL, 10);
-    p->majflt = (p->majflt_raw - last) * (1000000ULL * RATES_DETAIL) / (p->stat_collected_usec - p->last_stat_collected_usec);
+    p->majflt = (p->majflt_raw - last) * (USEC_PER_SEC * RATES_DETAIL) / (p->stat_collected_usec - p->last_stat_collected_usec);
 
     last = p->cmajflt_raw;
     p->cmajflt_raw      = strtoull(procfile_lineword(ff, 0, 12), NULL, 10);
-    p->cmajflt = (p->cmajflt_raw - last) * (1000000ULL * RATES_DETAIL) / (p->stat_collected_usec - p->last_stat_collected_usec);
+    p->cmajflt = (p->cmajflt_raw - last) * (USEC_PER_SEC * RATES_DETAIL) / (p->stat_collected_usec - p->last_stat_collected_usec);
 
     last = p->utime_raw;
     p->utime_raw        = strtoull(procfile_lineword(ff, 0, 13), NULL, 10);
-    p->utime = (p->utime_raw - last) * (1000000ULL * RATES_DETAIL) / (p->stat_collected_usec - p->last_stat_collected_usec);
+    p->utime = (p->utime_raw - last) * (USEC_PER_SEC * RATES_DETAIL) / (p->stat_collected_usec - p->last_stat_collected_usec);
 
     last = p->stime_raw;
     p->stime_raw        = strtoull(procfile_lineword(ff, 0, 14), NULL, 10);
-    p->stime = (p->stime_raw - last) * (1000000ULL * RATES_DETAIL) / (p->stat_collected_usec - p->last_stat_collected_usec);
+    p->stime = (p->stime_raw - last) * (USEC_PER_SEC * RATES_DETAIL) / (p->stat_collected_usec - p->last_stat_collected_usec);
 
     last = p->cutime_raw;
     p->cutime_raw       = strtoull(procfile_lineword(ff, 0, 15), NULL, 10);
-    p->cutime = (p->cutime_raw - last) * (1000000ULL * RATES_DETAIL) / (p->stat_collected_usec - p->last_stat_collected_usec);
+    p->cutime = (p->cutime_raw - last) * (USEC_PER_SEC * RATES_DETAIL) / (p->stat_collected_usec - p->last_stat_collected_usec);
 
     last = p->cstime_raw;
     p->cstime_raw       = strtoull(procfile_lineword(ff, 0, 16), NULL, 10);
-    p->cstime = (p->cstime_raw - last) * (1000000ULL * RATES_DETAIL) / (p->stat_collected_usec - p->last_stat_collected_usec);
+    p->cstime = (p->cstime_raw - last) * (USEC_PER_SEC * RATES_DETAIL) / (p->stat_collected_usec - p->last_stat_collected_usec);
 
     // p->priority      = strtoull(procfile_lineword(ff, 0, 17), NULL, 10);
     // p->nice          = strtoull(procfile_lineword(ff, 0, 18), NULL, 10);
@@ -670,11 +670,11 @@ int read_proc_pid_stat(struct pid_stat *p) {
     if(enable_guest_charts) {
         last = p->gtime_raw;
         p->gtime_raw        = strtoull(procfile_lineword(ff, 0, 42), NULL, 10);
-        p->gtime = (p->gtime_raw - last) * (1000000ULL * RATES_DETAIL) / (p->stat_collected_usec - p->last_stat_collected_usec);
+        p->gtime = (p->gtime_raw - last) * (USEC_PER_SEC * RATES_DETAIL) / (p->stat_collected_usec - p->last_stat_collected_usec);
 
         last = p->cgtime_raw;
         p->cgtime_raw       = strtoull(procfile_lineword(ff, 0, 43), NULL, 10);
-        p->cgtime = (p->cgtime_raw - last) * (1000000ULL * RATES_DETAIL) / (p->stat_collected_usec - p->last_stat_collected_usec);
+        p->cgtime = (p->cgtime_raw - last) * (USEC_PER_SEC * RATES_DETAIL) / (p->stat_collected_usec - p->last_stat_collected_usec);
 
         if (show_guest_time || p->gtime || p->cgtime) {
             p->utime -= (p->utime >= p->gtime) ? p->gtime : p->utime;
@@ -780,31 +780,31 @@ int read_proc_pid_io(struct pid_stat *p) {
 
     last = p->io_logical_bytes_read_raw;
     p->io_logical_bytes_read_raw = strtoull(procfile_lineword(ff, 0, 1), NULL, 10);
-    p->io_logical_bytes_read = (p->io_logical_bytes_read_raw - last) * (1000000ULL * RATES_DETAIL) / (p->io_collected_usec - p->last_io_collected_usec);
+    p->io_logical_bytes_read = (p->io_logical_bytes_read_raw - last) * (USEC_PER_SEC * RATES_DETAIL) / (p->io_collected_usec - p->last_io_collected_usec);
 
     last = p->io_logical_bytes_written_raw;
     p->io_logical_bytes_written_raw = strtoull(procfile_lineword(ff, 1, 1), NULL, 10);
-    p->io_logical_bytes_written = (p->io_logical_bytes_written_raw - last) * (1000000ULL * RATES_DETAIL) / (p->io_collected_usec - p->last_io_collected_usec);
+    p->io_logical_bytes_written = (p->io_logical_bytes_written_raw - last) * (USEC_PER_SEC * RATES_DETAIL) / (p->io_collected_usec - p->last_io_collected_usec);
 
     // last = p->io_read_calls_raw;
     // p->io_read_calls_raw = strtoull(procfile_lineword(ff, 2, 1), NULL, 10);
-    // p->io_read_calls = (p->io_read_calls_raw - last) * (1000000ULL * RATES_DETAIL) / (p->io_collected_usec - p->last_io_collected_usec);
+    // p->io_read_calls = (p->io_read_calls_raw - last) * (USEC_PER_SEC * RATES_DETAIL) / (p->io_collected_usec - p->last_io_collected_usec);
 
     // last = p->io_write_calls_raw;
     // p->io_write_calls_raw = strtoull(procfile_lineword(ff, 3, 1), NULL, 10);
-    // p->io_write_calls = (p->io_write_calls_raw - last) * (1000000ULL * RATES_DETAIL) / (p->io_collected_usec - p->last_io_collected_usec);
+    // p->io_write_calls = (p->io_write_calls_raw - last) * (USEC_PER_SEC * RATES_DETAIL) / (p->io_collected_usec - p->last_io_collected_usec);
 
     last = p->io_storage_bytes_read_raw;
     p->io_storage_bytes_read_raw = strtoull(procfile_lineword(ff, 4, 1), NULL, 10);
-    p->io_storage_bytes_read = (p->io_storage_bytes_read_raw - last) * (1000000ULL * RATES_DETAIL) / (p->io_collected_usec - p->last_io_collected_usec);
+    p->io_storage_bytes_read = (p->io_storage_bytes_read_raw - last) * (USEC_PER_SEC * RATES_DETAIL) / (p->io_collected_usec - p->last_io_collected_usec);
 
     last = p->io_storage_bytes_written_raw;
     p->io_storage_bytes_written_raw = strtoull(procfile_lineword(ff, 5, 1), NULL, 10);
-    p->io_storage_bytes_written = (p->io_storage_bytes_written_raw - last) * (1000000ULL * RATES_DETAIL) / (p->io_collected_usec - p->last_io_collected_usec);
+    p->io_storage_bytes_written = (p->io_storage_bytes_written_raw - last) * (USEC_PER_SEC * RATES_DETAIL) / (p->io_collected_usec - p->last_io_collected_usec);
 
     // last = p->io_cancelled_write_bytes_raw;
     // p->io_cancelled_write_bytes_raw = strtoull(procfile_lineword(ff, 6, 1), NULL, 10);
-    // p->io_cancelled_write_bytes = (p->io_cancelled_write_bytes_raw - last) * (1000000ULL * RATES_DETAIL) / (p->io_collected_usec - p->last_io_collected_usec);
+    // p->io_cancelled_write_bytes = (p->io_cancelled_write_bytes_raw - last) * (USEC_PER_SEC * RATES_DETAIL) / (p->io_collected_usec - p->last_io_collected_usec);
 
     if(unlikely(global_iterations_counter == 1)) {
         p->io_logical_bytes_read        = 0;
@@ -836,7 +836,8 @@ unsigned long long global_gtime = 0;
 int read_proc_stat() {
     static char filename[FILENAME_MAX + 1] = "";
     static procfile *ff = NULL;
-    static unsigned long long utime_raw = 0, stime_raw = 0, gtime_raw = 0, gntime_raw = 0, ntime_raw = 0, collected_usec = 0, last_collected_usec = 0;
+    static unsigned long long utime_raw = 0, stime_raw = 0, gtime_raw = 0, gntime_raw = 0, ntime_raw = 0;
+    static usec_t collected_usec = 0, last_collected_usec = 0;
 
     if(unlikely(!ff)) {
         snprintfz(filename, FILENAME_MAX, "%s/proc/stat", global_host_prefix);
@@ -856,26 +857,26 @@ int read_proc_stat() {
 
     last = utime_raw;
     utime_raw = strtoull(procfile_lineword(ff, 0, 1), NULL, 10);
-    global_utime = (utime_raw - last) * (1000000ULL * RATES_DETAIL) / (collected_usec - last_collected_usec);
+    global_utime = (utime_raw - last) * (USEC_PER_SEC * RATES_DETAIL) / (collected_usec - last_collected_usec);
 
     // nice time, on user time
     last = ntime_raw;
     ntime_raw = strtoull(procfile_lineword(ff, 0, 2), NULL, 10);
-    global_utime += (ntime_raw - last) * (1000000ULL * RATES_DETAIL) / (collected_usec - last_collected_usec);
+    global_utime += (ntime_raw - last) * (USEC_PER_SEC * RATES_DETAIL) / (collected_usec - last_collected_usec);
 
     last = stime_raw;
     stime_raw = strtoull(procfile_lineword(ff, 0, 3), NULL, 10);
-    global_stime = (stime_raw - last) * (1000000ULL * RATES_DETAIL) / (collected_usec - last_collected_usec);
+    global_stime = (stime_raw - last) * (USEC_PER_SEC * RATES_DETAIL) / (collected_usec - last_collected_usec);
 
     last = gtime_raw;
     gtime_raw = strtoull(procfile_lineword(ff, 0, 10), NULL, 10);
-    global_gtime = (gtime_raw - last) * (1000000ULL * RATES_DETAIL) / (collected_usec - last_collected_usec);
+    global_gtime = (gtime_raw - last) * (USEC_PER_SEC * RATES_DETAIL) / (collected_usec - last_collected_usec);
 
     if(enable_guest_charts) {
         // guest nice time, on guest time
         last = gntime_raw;
         gntime_raw = strtoull(procfile_lineword(ff, 0, 11), NULL, 10);
-        global_gtime += (gntime_raw - last) * (1000000ULL * RATES_DETAIL) / (collected_usec - last_collected_usec);
+        global_gtime += (gntime_raw - last) * (USEC_PER_SEC * RATES_DETAIL) / (collected_usec - last_collected_usec);
 
         // remove guest time from user time
         global_utime -= (global_utime > global_gtime) ? global_gtime : global_utime;
@@ -1441,11 +1442,11 @@ void process_exited_processes() {
                         );
             }
 
-            p->utime_raw   = utime  * (p->stat_collected_usec - p->last_stat_collected_usec) / (1000000ULL * RATES_DETAIL);
-            p->stime_raw   = stime  * (p->stat_collected_usec - p->last_stat_collected_usec) / (1000000ULL * RATES_DETAIL);
-            p->gtime_raw   = gtime  * (p->stat_collected_usec - p->last_stat_collected_usec) / (1000000ULL * RATES_DETAIL);
-            p->minflt_raw  = minflt * (p->stat_collected_usec - p->last_stat_collected_usec) / (1000000ULL * RATES_DETAIL);
-            p->majflt_raw  = majflt * (p->stat_collected_usec - p->last_stat_collected_usec) / (1000000ULL * RATES_DETAIL);
+            p->utime_raw   = utime  * (p->stat_collected_usec - p->last_stat_collected_usec) / (USEC_PER_SEC * RATES_DETAIL);
+            p->stime_raw   = stime  * (p->stat_collected_usec - p->last_stat_collected_usec) / (USEC_PER_SEC * RATES_DETAIL);
+            p->gtime_raw   = gtime  * (p->stat_collected_usec - p->last_stat_collected_usec) / (USEC_PER_SEC * RATES_DETAIL);
+            p->minflt_raw  = minflt * (p->stat_collected_usec - p->last_stat_collected_usec) / (USEC_PER_SEC * RATES_DETAIL);
+            p->majflt_raw  = majflt * (p->stat_collected_usec - p->last_stat_collected_usec) / (USEC_PER_SEC * RATES_DETAIL);
             p->cutime_raw = p->cstime_raw = p->cgtime_raw = p->cminflt_raw = p->cmajflt_raw = 0;
 
             if(unlikely(debug))
@@ -2147,16 +2148,16 @@ static inline void send_END(void) {
 double utime_fix_ratio = 1.0, stime_fix_ratio = 1.0, gtime_fix_ratio = 1.0, cutime_fix_ratio = 1.0, cstime_fix_ratio = 1.0, cgtime_fix_ratio = 1.0;
 double minflt_fix_ratio = 1.0, majflt_fix_ratio = 1.0, cminflt_fix_ratio = 1.0, cmajflt_fix_ratio = 1.0;
 
-unsigned long long send_resource_usage_to_netdata() {
+usec_t send_resource_usage_to_netdata() {
     static struct timeval last = { 0, 0 };
     static struct rusage me_last;
 
     struct timeval now;
     struct rusage me;
 
-    unsigned long long usec;
-    unsigned long long cpuuser;
-    unsigned long long cpusyst;
+    usec_t usec;
+    usec_t cpuuser;
+    usec_t cpusyst;
 
     if(!last.tv_sec) {
         now_realtime_timeval(&last);
@@ -2164,7 +2165,7 @@ unsigned long long send_resource_usage_to_netdata() {
 
         // the first time, give a zero to allow
         // netdata calibrate to the current time
-        // usec = update_every * 1000000ULL;
+        // usec = update_every * USEC_PER_SEC;
         usec = 0ULL;
         cpuuser = 0;
         cpusyst = 0;
@@ -2174,8 +2175,8 @@ unsigned long long send_resource_usage_to_netdata() {
         getrusage(RUSAGE_SELF, &me);
 
         usec = dt_usec(&now, &last);
-        cpuuser = me.ru_utime.tv_sec * 1000000ULL + me.ru_utime.tv_usec;
-        cpusyst = me.ru_stime.tv_sec * 1000000ULL + me.ru_stime.tv_usec;
+        cpuuser = me.ru_utime.tv_sec * USEC_PER_SEC + me.ru_utime.tv_usec;
+        cpusyst = me.ru_stime.tv_sec * USEC_PER_SEC + me.ru_stime.tv_usec;
 
         memmove(&last, &now, sizeof(struct timeval));
         memmove(&me_last, &me, sizeof(struct rusage));
@@ -2381,7 +2382,7 @@ void normalize_data(struct target *root) {
     }
 }
 
-void send_collected_data_to_netdata(struct target *root, const char *type, unsigned long long usec) {
+void send_collected_data_to_netdata(struct target *root, const char *type, usec_t usec) {
     struct target *w;
 
     send_BEGIN(type, "cpu", usec);
@@ -2840,11 +2841,11 @@ int main(int argc, char **argv)
             , RATES_DETAIL
             );
 
-    unsigned long long step = update_every * 1000000ULL;
+    usec_t step = update_every * USEC_PER_SEC;
     global_iterations_counter = 1;
     for(;1; global_iterations_counter++) {
-        unsigned long long now = now_realtime_usec();
-        unsigned long long next = now - (now % step) + step;
+        usec_t now = now_realtime_usec();
+        usec_t next = now - (now % step) + step;
 
         while(now < next) {
             sleep_usec(next - now);
@@ -2860,7 +2861,7 @@ int main(int argc, char **argv)
         calculate_netdata_statistics();
         normalize_data(apps_groups_root_target);
 
-        unsigned long long dt = send_resource_usage_to_netdata();
+        usec_t dt = send_resource_usage_to_netdata();
 
         // this is smart enough to show only newly added apps, when needed
         send_charts_updates_to_netdata(apps_groups_root_target, "apps", "Apps");

diff --git a/src/backends.c b/src/backends.c
index 69a61414445a143d57c26790a09e9844bae96e4e..34e032fa9ed3f046ea1c0e0e8f1cc918f2688d66 100644 (file)
--- a/src/backends.c
+++ b/src/backends.c
@@ -395,9 +395,9 @@ void *backends_main(void *ptr) {
 
     info("BACKEND configured ('%s' on '%s' sending '%s' data, every %d seconds, as host '%s', with prefix '%s')", type, destination, source, frequency, hostname, prefix);
 
-    unsigned long long step_ut = frequency * 1000000ULL;
-    unsigned long long random_ut = now_realtime_usec() % (step_ut / 2);
-    time_t before = (time_t)((now_realtime_usec() - step_ut) / 10000000ULL);
+    usec_t step_ut = frequency * USEC_PER_SEC;
+    usec_t random_ut = now_realtime_usec() % (step_ut / 2);
+    time_t before = (time_t)((now_realtime_usec() - step_ut) / USEC_PER_SEC);
     time_t after = before;
     int failures = 0;
 
@@ -405,9 +405,9 @@ void *backends_main(void *ptr) {
         // ------------------------------------------------------------------------
         // wait for the next iteration point
 
-        unsigned long long now_ut = now_realtime_usec();
-        unsigned long long next_ut = now_ut - (now_ut % step_ut) + step_ut;
-        before = (time_t)(next_ut / 1000000ULL);
+        usec_t now_ut = now_realtime_usec();
+        usec_t next_ut = now_ut - (now_ut % step_ut) + step_ut;
+        before = (time_t)(next_ut / USEC_PER_SEC);
 
         // add a little delay (1/4 of the step) plus some randomness
         next_ut += (step_ut / 4) + random_ut;
@@ -465,7 +465,7 @@ void *backends_main(void *ptr) {
         // connect to a backend server
 
         if(unlikely(sock == -1)) {
-            unsigned long long start_ut = now_realtime_usec();
+            usec_t start_ut = now_realtime_usec();
             const char *s = destination;
             while(*s) {
                 const char *e = s;
@@ -496,7 +496,7 @@ void *backends_main(void *ptr) {
 
         if(likely(sock != -1)) {
             size_t len = buffer_strlen(b);
-            unsigned long long start_ut = now_realtime_usec();
+            usec_t start_ut = now_realtime_usec();
             int flags = 0;
 #ifdef MSG_NOSIGNAL
             flags += MSG_NOSIGNAL;

diff --git a/src/common.c b/src/common.c
index 4fdfe633ec1e2b6477fe192182484bcb31ee03e3..24aa4af60a47ab6b8180bf62793a0a4c51fc1bc2 100644 (file)
--- a/src/common.c
+++ b/src/common.c
@@ -197,7 +197,7 @@ void freez(void *ptr) {
     free(ptr);
 }
 
-int sleep_usec(unsigned long long usec) {
+int sleep_usec(usec_t usec) {
 
 #ifndef NETDATA_WITH_USLEEP
     // we expect microseconds (1.000.000 per second)

diff --git a/src/common.h b/src/common.h
index 9c87d890e0e3ffe76f06673516938f3521d2ac62..5efb788aebbb65f641328b756eba6833bd676329 100644 (file)
--- a/src/common.h
+++ b/src/common.h
@@ -100,6 +100,7 @@
 #endif // __GNUC__
 
 #include "avl.h"
+#include "clocks.h"
 #include "log.h"
 #include "global_statistics.h"
 #include "storage_number.h"
@@ -123,7 +124,6 @@
 #include "plugin_tc.h"
 #include "plugins_d.h"
 
-#include "clocks.h"
 #include "eval.h"
 #include "health.h"
 
@@ -191,7 +191,7 @@ extern int enable_ksm;
 
 extern pid_t gettid(void);
 
-extern int sleep_usec(unsigned long long usec);
+extern int sleep_usec(usec_t usec);
 
 extern char *fgets_trim_len(char *buf, size_t buf_size, FILE *fp, size_t *len);
 

diff --git a/src/freebsd_sysctl.c b/src/freebsd_sysctl.c
index 0fc45292012e3e2e615ccb3905aa301f39c88697..dfee1e844ac5591a69adedcf517be9f0fad852a4 100644 (file)
--- a/src/freebsd_sysctl.c
+++ b/src/freebsd_sysctl.c
@@ -12,7 +12,7 @@
 // FreeBSD calculates load averages once every 5 seconds
 #define MIN_LOADAVG_UPDATE_EVERY 5
 
-int do_freebsd_sysctl(int update_every, unsigned long long dt) {
+int do_freebsd_sysctl(int update_every, usec_t dt) {
     (void)dt;
 
     static int do_cpu = -1, do_cpu_cores = -1, do_interrupts = -1, do_context = -1, do_forks = -1, do_processes = -1,
@@ -42,7 +42,7 @@ int do_freebsd_sysctl(int update_every, unsigned long long dt) {
     int i;
 
 // NEEDED BY: do_loadavg
-    static unsigned long long last_loadavg_usec = 0;
+    static usec_t last_loadavg_usec = 0;
     struct loadavg sysload;
 
 // NEEDED BY: do_cpu, do_cpu_cores
@@ -125,7 +125,7 @@ int do_freebsd_sysctl(int update_every, unsigned long long dt) {
             }
         }
 
-        last_loadavg_usec = st->update_every * 1000000ULL;
+        last_loadavg_usec = st->update_every * USEC_PER_SEC;
     }
     else last_loadavg_usec -= dt;
 

diff --git a/src/health.c b/src/health.c
index c14c29d8737d122d207371e9a3c21ce0ee5ef872..849a3faf9646a07ca997d8393f747ad8c51bb133 100755 (executable)
--- a/src/health.c
+++ b/src/health.c
@@ -3101,7 +3101,7 @@ void *health_main(void *ptr) {
         if(now < next_run) {
             debug(D_HEALTH, "Health monitoring iteration no %u done. Next iteration in %d secs",
                   loop, (int) (next_run - now));
-            sleep_usec(1000000 * (unsigned long long) (next_run - now));
+            sleep_usec(USEC_PER_SEC * (usec_t) (next_run - now));
         }
         else {
             debug(D_HEALTH, "Health monitoring iteration no %u done. Next iteration now", loop);

diff --git a/src/ipc.c b/src/ipc.c
index 3cf76513dce8b27bbf46367fce5d9f54a7451adf..6a261c5c20a9bb9e2355bdcc63d47003550b491b 100644 (file)
--- a/src/ipc.c
+++ b/src/ipc.c
@@ -160,7 +160,7 @@ static inline int ipc_sem_get_status(struct ipc_status *st) {
     return 0;
 }
 
-int do_ipc(int update_every, unsigned long long dt) {
+int do_ipc(int update_every, usec_t dt) {
     (void)dt;
 
     static int initialized = 0, read_limits_next = 0;

diff --git a/src/ipc.h b/src/ipc.h
index 3762a69d76bdcc21e7ef7d1844ea041324d6c65a..04f9df5cdf046f98b8bc2ba9d51d9e4d3f12fd5c 100644 (file)
--- a/src/ipc.h
+++ b/src/ipc.h
@@ -1,7 +1,7 @@
 #ifndef NETDATA_PLUGIN_IPC_H
 #define NETDATA_PLUGIN_IPC_H 1
 
-extern int do_ipc(int update_every, unsigned long long dt);
+extern int do_ipc(int update_every, usec_t dt);
 
 #endif /* NETDATA_PLUGIN_IPC_H */
 

diff --git a/src/plugin_checks.c b/src/plugin_checks.c
index 18b1d1684a56663e2a061d8274317c9922ca46bc..12f48ff85556bedd9e3b7e6d1156e6f02c2e7dd2 100644 (file)
--- a/src/plugin_checks.c
+++ b/src/plugin_checks.c
@@ -12,7 +12,7 @@ void *checks_main(void *ptr)
     if(pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, NULL) != 0)
         error("Cannot set pthread cancel state to ENABLE.");
 
-    unsigned long long usec = 0, susec = rrd_update_every * 1000000ULL, loop_usec = 0, total_susec = 0;
+    usec_t usec = 0, susec = rrd_update_every * USEC_PER_SEC, loop_usec = 0, total_susec = 0;
     struct timeval now, last, loop;
 
     RRDSET *check1, *check2, *check3, *apps_cpu = NULL;
@@ -40,8 +40,8 @@ void *checks_main(void *ptr)
         usec = loop_usec - susec;
         debug(D_PROCNETDEV_LOOP, "CHECK: last loop took %llu usec (worked for %llu, sleeped for %llu).", loop_usec, usec, susec);
 
-        if(usec < (rrd_update_every * 1000000ULL / 2ULL)) susec = (rrd_update_every * 1000000ULL) - usec;
-        else susec = rrd_update_every * 1000000ULL / 2ULL;
+        if(usec < (rrd_update_every * USEC_PER_SEC / 2ULL)) susec = (rrd_update_every * USEC_PER_SEC) - usec;
+        else susec = rrd_update_every * USEC_PER_SEC / 2ULL;
 
         // --------------------------------------------------------------------
         // Calculate loop time

diff --git a/src/plugin_freebsd.c b/src/plugin_freebsd.c
index 4f59fc85cefd4ab1f45b223db692498e0c8f562b..9231b538294e01c329e85486c30559c370624448 100644 (file)
--- a/src/plugin_freebsd.c
+++ b/src/plugin_freebsd.c
@@ -25,10 +25,10 @@ void *freebsd_main(void *ptr)
     // keep track of the time each module was called
     unsigned long long sutime_freebsd_sysctl = 0ULL;
 
-    unsigned long long step = rrd_update_every * 1000000ULL;
+    usec_t step = rrd_update_every * USEC_PER_SEC;
     for(;;) {
-        unsigned long long now = now_realtime_usec();
-        unsigned long long next = now - (now % step) + step;
+        usec_t now = now_realtime_usec();
+        usec_t next = now - (now % step) + step;
 
         while(now < next) {
             sleep_usec(next - now);

diff --git a/src/plugin_freebsd.h b/src/plugin_freebsd.h
index ee432bfc6d1af78f36c57f8eff2bf4665f0b4488..4ae1a4c21831e7b8ba7f291c6794dbb2190d8d5a 100644 (file)
--- a/src/plugin_freebsd.h
+++ b/src/plugin_freebsd.h
@@ -7,6 +7,6 @@ void *freebsd_main(void *ptr);
 
 int getsysctl(const char *name, void *ptr, size_t len);
 
-extern int do_freebsd_sysctl(int update_every, unsigned long long dt);
+extern int do_freebsd_sysctl(int update_every, usec_t dt);
 
 #endif /* NETDATA_PLUGIN_FREEBSD_H */

diff --git a/src/plugin_idlejitter.c b/src/plugin_idlejitter.c
index b1273f001cd4a8bb693967d73bcbb85edffb1f1e..77fab3fa8b605f3dc371a74079830ad09a3cda3c 100644 (file)
--- a/src/plugin_idlejitter.c
+++ b/src/plugin_idlejitter.c
@@ -29,9 +29,9 @@ void *cpuidlejitter_main(void *ptr)
     struct timeval before, after;
     unsigned long long counter;
     for(counter = 0; 1 ;counter++) {
-        unsigned long long usec = 0, susec = 0;
+        usec_t usec = 0, susec = 0;
 
-        while(susec < (rrd_update_every * 1000000ULL)) {
+        while(susec < (rrd_update_every * USEC_PER_SEC)) {
 
             now_realtime_timeval(&before);
             sleep_usec(sleep_ms * 1000);

diff --git a/src/plugin_nfacct.c b/src/plugin_nfacct.c
index 72ecc7b3673444a9ad2a43b64b8de627c8a309a7..03de379170f4f8847def30e8d6ffcd674a1f868c 100644 (file)
--- a/src/plugin_nfacct.c
+++ b/src/plugin_nfacct.c
@@ -90,7 +90,7 @@ void *nfacct_main(void *ptr) {
     // ------------------------------------------------------------------------
 
     struct timeval last, now;
-    unsigned long long usec = 0, susec = 0;
+    usec_t usec = 0, susec = 0;
     RRDSET *st = NULL;
 
     now_realtime_timeval(&last);

diff --git a/src/plugin_proc.c b/src/plugin_proc.c
index c6d4304e69afa15a4f7e1eca3e78457f3e44e4f1..4188c9a2b617334d2b3eec2b630ebc4e7a09bc89 100644 (file)
--- a/src/plugin_proc.c
+++ b/src/plugin_proc.c
@@ -40,31 +40,31 @@ void *proc_main(void *ptr)
     int vdo_cpu_netdata             = !config_get_boolean("plugin:proc", "netdata server resources", 1);
 
     // keep track of the time each module was called
-    unsigned long long sutime_proc_net_dev = 0ULL;
-    unsigned long long sutime_proc_diskstats = 0ULL;
-    unsigned long long sutime_proc_net_snmp = 0ULL;
-    unsigned long long sutime_proc_net_snmp6 = 0ULL;
-    unsigned long long sutime_proc_net_netstat = 0ULL;
-    unsigned long long sutime_proc_net_stat_conntrack = 0ULL;
-    unsigned long long sutime_proc_net_ip_vs_stats = 0ULL;
-    unsigned long long sutime_proc_net_stat_synproxy = 0ULL;
-    unsigned long long sutime_proc_stat = 0ULL;
-    unsigned long long sutime_proc_meminfo = 0ULL;
-    unsigned long long sutime_proc_vmstat = 0ULL;
-    unsigned long long sutime_proc_net_rpc_nfs = 0ULL;
-    unsigned long long sutime_proc_net_rpc_nfsd = 0ULL;
-    unsigned long long sutime_proc_sys_kernel_random_entropy_avail = 0ULL;
-    unsigned long long sutime_proc_interrupts = 0ULL;
-    unsigned long long sutime_proc_softirqs = 0ULL;
-    unsigned long long sutime_proc_net_softnet_stat = 0ULL;
-    unsigned long long sutime_proc_loadavg = 0ULL;
-    unsigned long long sutime_ipc = 0ULL;
-    unsigned long long sutime_sys_kernel_mm_ksm = 0ULL;
-
-    unsigned long long step = rrd_update_every * 1000000ULL;
+    usec_t sutime_proc_net_dev = 0ULL;
+    usec_t sutime_proc_diskstats = 0ULL;
+    usec_t sutime_proc_net_snmp = 0ULL;
+    usec_t sutime_proc_net_snmp6 = 0ULL;
+    usec_t sutime_proc_net_netstat = 0ULL;
+    usec_t sutime_proc_net_stat_conntrack = 0ULL;
+    usec_t sutime_proc_net_ip_vs_stats = 0ULL;
+    usec_t sutime_proc_net_stat_synproxy = 0ULL;
+    usec_t sutime_proc_stat = 0ULL;
+    usec_t sutime_proc_meminfo = 0ULL;
+    usec_t sutime_proc_vmstat = 0ULL;
+    usec_t sutime_proc_net_rpc_nfs = 0ULL;
+    usec_t sutime_proc_net_rpc_nfsd = 0ULL;
+    usec_t sutime_proc_sys_kernel_random_entropy_avail = 0ULL;
+    usec_t sutime_proc_interrupts = 0ULL;
+    usec_t sutime_proc_softirqs = 0ULL;
+    usec_t sutime_proc_net_softnet_stat = 0ULL;
+    usec_t sutime_proc_loadavg = 0ULL;
+    usec_t sutime_ipc = 0ULL;
+    usec_t sutime_sys_kernel_mm_ksm = 0ULL;
+
+    usec_t step = rrd_update_every * USEC_PER_SEC;
     for(;;) {
-        unsigned long long now = now_realtime_usec();
-        unsigned long long next = now - (now % step) + step;
+        usec_t now = now_realtime_usec();
+        usec_t next = now - (now % step) + step;
 
         while(now < next) {
             sleep_usec(next - now);

diff --git a/src/plugin_proc.h b/src/plugin_proc.h
index f72a9970f38cb1c19c8a7d20f62802e338cec5d8..4e0cbc3ceed0c1c73c9598d0d0073f1ef1aae483 100644 (file)
--- a/src/plugin_proc.h
+++ b/src/plugin_proc.h
@@ -3,24 +3,24 @@
 
 void *proc_main(void *ptr);
 
-extern int do_proc_net_dev(int update_every, unsigned long long dt);
-extern int do_proc_diskstats(int update_every, unsigned long long dt);
-extern int do_proc_net_snmp(int update_every, unsigned long long dt);
-extern int do_proc_net_snmp6(int update_every, unsigned long long dt);
-extern int do_proc_net_netstat(int update_every, unsigned long long dt);
-extern int do_proc_net_stat_conntrack(int update_every, unsigned long long dt);
-extern int do_proc_net_ip_vs_stats(int update_every, unsigned long long dt);
-extern int do_proc_stat(int update_every, unsigned long long dt);
-extern int do_proc_meminfo(int update_every, unsigned long long dt);
-extern int do_proc_vmstat(int update_every, unsigned long long dt);
-extern int do_proc_net_rpc_nfs(int update_every, unsigned long long dt);
-extern int do_proc_net_rpc_nfsd(int update_every, unsigned long long dt);
-extern int do_proc_sys_kernel_random_entropy_avail(int update_every, unsigned long long dt);
-extern int do_proc_interrupts(int update_every, unsigned long long dt);
-extern int do_proc_softirqs(int update_every, unsigned long long dt);
-extern int do_sys_kernel_mm_ksm(int update_every, unsigned long long dt);
-extern int do_proc_loadavg(int update_every, unsigned long long dt);
-extern int do_proc_net_stat_synproxy(int update_every, unsigned long long dt);
-extern int do_proc_net_softnet_stat(int update_every, unsigned long long dt);
+extern int do_proc_net_dev(int update_every, usec_t dt);
+extern int do_proc_diskstats(int update_every, usec_t dt);
+extern int do_proc_net_snmp(int update_every, usec_t dt);
+extern int do_proc_net_snmp6(int update_every, usec_t dt);
+extern int do_proc_net_netstat(int update_every, usec_t dt);
+extern int do_proc_net_stat_conntrack(int update_every, usec_t dt);
+extern int do_proc_net_ip_vs_stats(int update_every, usec_t dt);
+extern int do_proc_stat(int update_every, usec_t dt);
+extern int do_proc_meminfo(int update_every, usec_t dt);
+extern int do_proc_vmstat(int update_every, usec_t dt);
+extern int do_proc_net_rpc_nfs(int update_every, usec_t dt);
+extern int do_proc_net_rpc_nfsd(int update_every, usec_t dt);
+extern int do_proc_sys_kernel_random_entropy_avail(int update_every, usec_t dt);
+extern int do_proc_interrupts(int update_every, usec_t dt);
+extern int do_proc_softirqs(int update_every, usec_t dt);
+extern int do_sys_kernel_mm_ksm(int update_every, usec_t dt);
+extern int do_proc_loadavg(int update_every, usec_t dt);
+extern int do_proc_net_stat_synproxy(int update_every, usec_t dt);
+extern int do_proc_net_softnet_stat(int update_every, usec_t dt);
 
 #endif /* NETDATA_PLUGIN_PROC_H */

diff --git a/src/plugins_d.c b/src/plugins_d.c
index d1784ba691b0b5e6589224ad6bee528fe1c72033..8036b632dc8fbf1ea00e390122bca6447e0fa397 100644 (file)
--- a/src/plugins_d.c
+++ b/src/plugins_d.c
@@ -90,7 +90,7 @@ void *pluginsd_worker_thread(void *arg)
     char line[PLUGINSD_LINE_MAX + 1];
 
 #ifdef DETACH_PLUGINS_FROM_NETDATA
-    unsigned long long usec = 0, susec = 0;
+    usec_t usec = 0, susec = 0;
     struct timeval last = {0, 0} , now = {0, 0};
 #endif
 
@@ -185,7 +185,7 @@ void *pluginsd_worker_thread(void *arg)
                 }
 
                 if(likely(st->counter_done)) {
-                    unsigned long long microseconds = 0;
+                    usec_t microseconds = 0;
                     if(microseconds_txt && *microseconds_txt) microseconds = strtoull(microseconds_txt, NULL, 10);
                     if(microseconds) rrdset_next_usec(st, microseconds);
                     else rrdset_next(st);
@@ -344,14 +344,14 @@ void *pluginsd_worker_thread(void *arg)
                 now_realtime_timeval(&now);
                 if(unlikely(!usec && !susec)) {
                     // our first run
-                    susec = cd->rrd_update_every * 1000000ULL;
+                    susec = cd->rrd_update_every * USEC_PER_SEC;
                 }
                 else {
                     // second+ run
                     usec = dt_usec(&now, &last) - susec;
                     error("PLUGINSD: %s last loop took %llu usec (worked for %llu, sleeped for %llu).\n", cd->fullfilename, usec + susec, usec, susec);
-                    if(unlikely(usec < (rrd_update_every * 1000000ULL / 2ULL))) susec = (rrd_update_every * 1000000ULL) - usec;
-                    else susec = rrd_update_every * 1000000ULL / 2ULL;
+                    if(unlikely(usec < (rrd_update_every * USEC_PER_SEC / 2ULL))) susec = (rrd_update_every * USEC_PER_SEC) - usec;
+                    else susec = rrd_update_every * USEC_PER_SEC / 2ULL;
                 }
 
                 error("PLUGINSD: %s sleeping for %llu. Will kill with SIGCONT pid %d to wake it up.\n", cd->fullfilename, susec, cd->pid);

diff --git a/src/proc_diskstats.c b/src/proc_diskstats.c
index 26ac061f1063d139d7df233a351a1ac1d9829577..fe5b0556fa5dffff8c395bf9ee2ee4460464ab38 100644 (file)
--- a/src/proc_diskstats.c
+++ b/src/proc_diskstats.c
@@ -129,7 +129,7 @@ struct mount_point_metadata {
     int do_inodes;
 };
 
-static inline void do_disk_space_stats(struct mountinfo *mi, int update_every, unsigned long long dt) {
+static inline void do_disk_space_stats(struct mountinfo *mi, int update_every, usec_t dt) {
     (void)dt;
 
     const char *family = mi->mount_point;
@@ -411,7 +411,7 @@ static inline int select_positive_option(int option1, int option2) {
     return CONFIG_ONDEMAND_NO;
 }
 
-int do_proc_diskstats(int update_every, unsigned long long dt) {
+int do_proc_diskstats(int update_every, usec_t dt) {
     (void)dt;
 
     static procfile *ff = NULL;

diff --git a/src/proc_interrupts.c b/src/proc_interrupts.c
index 14215de68a24f497f208f72694ddffb60fe692cf..6d3d23995059d8aacc135723bc00e1d15d1e9811 100644 (file)
--- a/src/proc_interrupts.c
+++ b/src/proc_interrupts.c
@@ -29,7 +29,7 @@ static inline struct interrupt *get_interrupts_array(int lines, int cpus) {
     return irrs;
 }
 
-int do_proc_interrupts(int update_every, unsigned long long dt) {
+int do_proc_interrupts(int update_every, usec_t dt) {
     (void)dt;
 
     static procfile *ff = NULL;

diff --git a/src/proc_loadavg.c b/src/proc_loadavg.c
index a3d75ac53b9b717bb05a1f556912c0a814d5f070..c0f3902c8555cdefbda7755afc3906cc8eee7a1f 100644 (file)
--- a/src/proc_loadavg.c
+++ b/src/proc_loadavg.c
@@ -3,12 +3,12 @@
 // linux calculates this once every 5 seconds
 #define MIN_LOADAVG_UPDATE_EVERY 5
 
-int do_proc_loadavg(int update_every, unsigned long long dt) {
+int do_proc_loadavg(int update_every, usec_t dt) {
     (void)dt;
 
     static procfile *ff = NULL;
     static int do_loadavg = -1, do_all_processes = -1;
-    static unsigned long long last_loadavg_usec = 0;
+    static usec_t last_loadavg_usec = 0;
     static RRDSET *load_chart = NULL, *processes_chart = NULL;
 
     if(unlikely(!ff)) {
@@ -68,7 +68,7 @@ int do_proc_loadavg(int update_every, unsigned long long dt) {
             rrdset_done(load_chart);
         }
 
-        last_loadavg_usec = load_chart->update_every * 1000000ULL;
+        last_loadavg_usec = load_chart->update_every * USEC_PER_SEC;
     }
     else last_loadavg_usec -= dt;
 

diff --git a/src/proc_meminfo.c b/src/proc_meminfo.c
index 11b41be7bd3dc7ce9d178ce5a4fa3541fe6bfcc3..feed5d88d99036fe2a665af707bd5b3736196c76 100644 (file)
--- a/src/proc_meminfo.c
+++ b/src/proc_meminfo.c
@@ -1,6 +1,6 @@
 #include "common.h"
 
-int do_proc_meminfo(int update_every, unsigned long long dt) {
+int do_proc_meminfo(int update_every, usec_t dt) {
     (void)dt;
 
     static procfile *ff = NULL;

diff --git a/src/proc_net_dev.c b/src/proc_net_dev.c
index 33d140c471f1c97254b4793b769639b2ee8cdd64..06182d44ff9559f8a15673f7c9cbee853d6ec859 100644 (file)
--- a/src/proc_net_dev.c
+++ b/src/proc_net_dev.c
@@ -1,6 +1,6 @@
 #include "common.h"
 
-int do_proc_net_dev(int update_every, unsigned long long dt) {
+int do_proc_net_dev(int update_every, usec_t dt) {
     static procfile *ff = NULL;
     static int enable_new_interfaces = -1, enable_ifb_interfaces = -1;
     static int do_bandwidth = -1, do_packets = -1, do_errors = -1, do_drops = -1, do_fifo = -1, do_compressed = -1, do_events = -1;

diff --git a/src/proc_net_ip_vs_stats.c b/src/proc_net_ip_vs_stats.c
index de3e0e460cdd1b750d72e0f5e04a4c56b9213bef..3513a25f1d3d7279736238f2a292942f2c5c7509 100644 (file)
--- a/src/proc_net_ip_vs_stats.c
+++ b/src/proc_net_ip_vs_stats.c
@@ -3,7 +3,7 @@
 #define RRD_TYPE_NET_IPVS           "ipvs"
 #define RRD_TYPE_NET_IPVS_LEN       strlen(RRD_TYPE_NET_IPVS)
 
-int do_proc_net_ip_vs_stats(int update_every, unsigned long long dt) {
+int do_proc_net_ip_vs_stats(int update_every, usec_t dt) {
     static int do_bandwidth = -1, do_sockets = -1, do_packets = -1;
     static procfile *ff = NULL;
 

diff --git a/src/proc_net_netstat.c b/src/proc_net_netstat.c
index 00d26635f90c7e9e00e3b1cc1aa447a4636bdb98..14ac4ebb6d9842fa974136146394b326ea5aa8e4 100644 (file)
--- a/src/proc_net_netstat.c
+++ b/src/proc_net_netstat.c
@@ -191,7 +191,7 @@ static void parse_line_pair(procfile *ff, struct netstat_columns *nc, uint32_t h
 }
 
 
-int do_proc_net_netstat(int update_every, unsigned long long dt) {
+int do_proc_net_netstat(int update_every, usec_t dt) {
     (void)dt;
 
     static int do_bandwidth = -1, do_inerrors = -1, do_mcast = -1, do_bcast = -1, do_mcast_p = -1, do_bcast_p = -1, do_ecn = -1, \

diff --git a/src/proc_net_rpc_nfs.c b/src/proc_net_rpc_nfs.c
index 86e2f70c0d23a74f8f1e1a9edf2ab2281ef93663..b1c500f2b53f0050ec456db9821f4965f4012195 100644 (file)
--- a/src/proc_net_rpc_nfs.c
+++ b/src/proc_net_rpc_nfs.c
@@ -127,7 +127,7 @@ struct nfs_procs nfs_proc4_values[] = {
     { "", 0ULL, 0 }
 };
 
-int do_proc_net_rpc_nfs(int update_every, unsigned long long dt) {
+int do_proc_net_rpc_nfs(int update_every, usec_t dt) {
     (void)dt;
 
     static procfile *ff = NULL;

diff --git a/src/proc_net_rpc_nfsd.c b/src/proc_net_rpc_nfsd.c
index e0092c722d6ac15e8556303df8b411990c718978..863552056a2807e2348c5da8e9423108a4f04332 100644 (file)
--- a/src/proc_net_rpc_nfsd.c
+++ b/src/proc_net_rpc_nfsd.c
@@ -209,7 +209,7 @@ struct nfsd_procs nfsd4_ops_values[] = {
 };
 
 
-int do_proc_net_rpc_nfsd(int update_every, unsigned long long dt) {
+int do_proc_net_rpc_nfsd(int update_every, usec_t dt) {
     static procfile *ff = NULL;
     static int do_rc = -1, do_fh = -1, do_io = -1, do_th = -1, do_ra = -1, do_net = -1, do_rpc = -1, do_proc2 = -1, do_proc3 = -1, do_proc4 = -1, do_proc4ops = -1;
     static int ra_warning = 0, th_warning = 0, proc2_warning = 0, proc3_warning = 0, proc4_warning = 0, proc4ops_warning = 0;

diff --git a/src/proc_net_snmp.c b/src/proc_net_snmp.c
index 3ef111ba89e398471b68d0018f2c859f88dc0276..d7318fc817f8dda94a4a447430e1cc7c4ee59772 100644 (file)
--- a/src/proc_net_snmp.c
+++ b/src/proc_net_snmp.c
@@ -197,7 +197,7 @@ static void parse_line_pair(procfile *ff, struct netstat_columns *nc, uint32_t h
     }
 }
 
-int do_proc_net_snmp(int update_every, unsigned long long dt) {
+int do_proc_net_snmp(int update_every, usec_t dt) {
     (void)dt;
 
     static procfile *ff = NULL;

diff --git a/src/proc_net_snmp6.c b/src/proc_net_snmp6.c
index b7ec65c08cb9e967bac8e0db6a4c9d2759b02ec8..512943bd73e761bda7d652c4175e7f74bc04b1dc 100644 (file)
--- a/src/proc_net_snmp6.c
+++ b/src/proc_net_snmp6.c
@@ -3,7 +3,7 @@
 #define RRD_TYPE_NET_SNMP6          "ipv6"
 #define RRD_TYPE_NET_SNMP6_LEN      strlen(RRD_TYPE_NET_SNMP6)
 
-int do_proc_net_snmp6(int update_every, unsigned long long dt) {
+int do_proc_net_snmp6(int update_every, usec_t dt) {
     (void)dt;
 
     static procfile *ff = NULL;

diff --git a/src/proc_net_softnet_stat.c b/src/proc_net_softnet_stat.c
index 0187dbbc3f50a2936529f409aa716c4e4fa90497..7fe5b7d5dcd47cc3aea20e8f677ec6c8620f1e18 100644 (file)
--- a/src/proc_net_softnet_stat.c
+++ b/src/proc_net_softnet_stat.c
@@ -12,7 +12,7 @@ static inline char *softnet_column_name(uint32_t column) {
     }
 }
 
-int do_proc_net_softnet_stat(int update_every, unsigned long long dt) {
+int do_proc_net_softnet_stat(int update_every, usec_t dt) {
     (void)dt;
 
     static procfile *ff = NULL;

diff --git a/src/proc_net_stat_conntrack.c b/src/proc_net_stat_conntrack.c
index c61a4f3582a3c275d8150051d2eae3b5bc392ac2..3ccc96260886d0e41dad30c7c37bf2cdd8189349 100644 (file)
--- a/src/proc_net_stat_conntrack.c
+++ b/src/proc_net_stat_conntrack.c
@@ -3,10 +3,10 @@
 #define RRD_TYPE_NET_STAT_NETFILTER     "netfilter"
 #define RRD_TYPE_NET_STAT_CONNTRACK     "conntrack"
 
-int do_proc_net_stat_conntrack(int update_every, unsigned long long dt) {
+int do_proc_net_stat_conntrack(int update_every, usec_t dt) {
     static procfile *ff = NULL;
     static int do_sockets = -1, do_new = -1, do_changes = -1, do_expect = -1, do_search = -1, do_errors = -1;
-    static unsigned long long get_max_every = 10 * 1000000ULL, usec_since_last_max = 0;
+    static usec_t get_max_every = 10 * USEC_PER_SEC, usec_since_last_max = 0;
     static int read_full = 1;
     static char *nf_conntrack_filename, *nf_conntrack_count_filename, *nf_conntrack_max_filename;
     static RRDVAR *rrdvar_max = NULL;
@@ -21,7 +21,7 @@ int do_proc_net_stat_conntrack(int update_every, unsigned long long dt) {
 
         snprintfz(filename, FILENAME_MAX, "%s%s", global_host_prefix, "/proc/sys/net/netfilter/nf_conntrack_max");
         nf_conntrack_max_filename = config_get("plugin:proc:/proc/sys/net/netfilter/nf_conntrack_max", "filename to monitor", filename);
-        usec_since_last_max = get_max_every = config_get_number("plugin:proc:/proc/sys/net/netfilter/nf_conntrack_max", "read every seconds", 10) * 1000000ULL;
+        usec_since_last_max = get_max_every = config_get_number("plugin:proc:/proc/sys/net/netfilter/nf_conntrack_max", "read every seconds", 10) * USEC_PER_SEC;
 
         read_full = 1;
         ff = procfile_open(nf_conntrack_filename, " \t:", PROCFILE_FLAG_DEFAULT);

diff --git a/src/proc_net_stat_synproxy.c b/src/proc_net_stat_synproxy.c
index 01c91978b50d31424080548935522da806d1f304..c3ac00b5d7037d7938f8a1caab099113127bd4b9 100644 (file)
--- a/src/proc_net_stat_synproxy.c
+++ b/src/proc_net_stat_synproxy.c
@@ -3,7 +3,7 @@
 #define RRD_TYPE_NET_STAT_NETFILTER         "netfilter"
 #define RRD_TYPE_NET_STAT_SYNPROXY          "synproxy"
 
-int do_proc_net_stat_synproxy(int update_every, unsigned long long dt) {
+int do_proc_net_stat_synproxy(int update_every, usec_t dt) {
     (void)dt;
 
     static int do_entries = -1, do_cookies = -1, do_syns = -1, do_reopened = -1;

diff --git a/src/proc_softirqs.c b/src/proc_softirqs.c
index 818a6a7098294c950ce1517e9215ae632b4ddaac..319f97f7c74515c3af30a01224d1344049c0325d 100644 (file)
--- a/src/proc_softirqs.c
+++ b/src/proc_softirqs.c
@@ -29,7 +29,7 @@ static inline struct interrupt *get_interrupts_array(int lines, int cpus) {
     return irrs;
 }
 
-int do_proc_softirqs(int update_every, unsigned long long dt) {
+int do_proc_softirqs(int update_every, usec_t dt) {
     (void)dt;
 
     static procfile *ff = NULL;

diff --git a/src/proc_stat.c b/src/proc_stat.c
index 0e34f2eeec8017123fb352121eacc701c3b3d0ef..1a9b7a7fc02d04fdea4fc386fb9eb59ca6499fcf 100644 (file)
--- a/src/proc_stat.c
+++ b/src/proc_stat.c
@@ -1,6 +1,6 @@
 #include "common.h"
 
-int do_proc_stat(int update_every, unsigned long long dt) {
+int do_proc_stat(int update_every, usec_t dt) {
     (void)dt;
 
     static procfile *ff = NULL;

diff --git a/src/proc_sys_kernel_random_entropy_avail.c b/src/proc_sys_kernel_random_entropy_avail.c
index bde74f452196b7f35e2ee3e7c1e28793c56e1303..5c0893e351016cdd48a8349c55effb61d400e20c 100644 (file)
--- a/src/proc_sys_kernel_random_entropy_avail.c
+++ b/src/proc_sys_kernel_random_entropy_avail.c
@@ -1,6 +1,6 @@
 #include "common.h"
 
-int do_proc_sys_kernel_random_entropy_avail(int update_every, unsigned long long dt) {
+int do_proc_sys_kernel_random_entropy_avail(int update_every, usec_t dt) {
     (void)dt;
 
     static procfile *ff = NULL;

diff --git a/src/proc_vmstat.c b/src/proc_vmstat.c
index a8058398409077a2db021c43405e6794e0cc2672..2f4472a919a27152b68f07cb5d202934484012ea 100644 (file)
--- a/src/proc_vmstat.c
+++ b/src/proc_vmstat.c
@@ -1,6 +1,6 @@
 #include "common.h"
 
-int do_proc_vmstat(int update_every, unsigned long long dt) {
+int do_proc_vmstat(int update_every, usec_t dt) {
     (void)dt;
 
     static procfile *ff = NULL;

diff --git a/src/rrd.c b/src/rrd.c
index a03110eb148da3f4f1b58b2da18e72f82a9fb969..f24602e3934306cd6a291ecb5d3db5d36e35ad0a 100644 (file)
--- a/src/rrd.c
+++ b/src/rrd.c
@@ -685,7 +685,7 @@ RRDDIM *rrddim_add(RRDSET *st, const char *id, const char *name, long multiplier
             error("File %s does not have the same refresh frequency. Clearing it.", fullfilename);
             memset(rd, 0, size);
         }
-        else if(dt_usec(&now, &rd->last_collected_time) > (rd->entries * rd->update_every * 1000000ULL)) {
+        else if(dt_usec(&now, &rd->last_collected_time) > (rd->entries * rd->update_every * USEC_PER_SEC)) {
             errno = 0;
             error("File %s is too old. Clearing it.", fullfilename);
             memset(rd, 0, size);
@@ -998,23 +998,23 @@ collected_number rrddim_set(RRDSET *st, const char *id, collected_number value)
     return rrddim_set_by_pointer(st, rd, value);
 }
 
-void rrdset_next_usec_unfiltered(RRDSET *st, unsigned long long microseconds)
+void rrdset_next_usec_unfiltered(RRDSET *st, usec_t microseconds)
 {
     if(unlikely(!st->last_collected_time.tv_sec || !microseconds)) {
         // the first entry
-        microseconds = st->update_every * 1000000ULL;
+        microseconds = st->update_every * USEC_PER_SEC;
     }
     st->usec_since_last_update = microseconds;
 }
 
-void rrdset_next_usec(RRDSET *st, unsigned long long microseconds)
+void rrdset_next_usec(RRDSET *st, usec_t microseconds)
 {
     struct timeval now;
     now_realtime_timeval(&now);
 
     if(unlikely(!st->last_collected_time.tv_sec)) {
         // the first entry
-        microseconds = st->update_every * 1000000ULL;
+        microseconds = st->update_every * USEC_PER_SEC;
     }
     else if(unlikely(!microseconds)) {
         // no dt given by the plugin
@@ -1022,9 +1022,9 @@ void rrdset_next_usec(RRDSET *st, unsigned long long microseconds)
     }
     else {
         // microseconds has the time since the last collection
-        unsigned long long now_usec = timeval_usec(&now);
-        unsigned long long last_usec = timeval_usec(&st->last_collected_time);
-        unsigned long long since_last_usec = dt_usec(&now, &st->last_collected_time);
+        usec_t now_usec = timeval_usec(&now);
+        usec_t last_usec = timeval_usec(&st->last_collected_time);
+        usec_t since_last_usec = dt_usec(&now, &st->last_collected_time);
 
         // verify the microseconds given is good
         if(unlikely(microseconds > since_last_usec)) {
@@ -1052,7 +1052,7 @@ void rrdset_next_usec(RRDSET *st, unsigned long long microseconds)
     st->usec_since_last_update = microseconds;
 }
 
-unsigned long long rrdset_done(RRDSET *st)
+usec_t rrdset_done(RRDSET *st)
 {
     if(unlikely(netdata_exit)) return 0;
 
@@ -1070,12 +1070,12 @@ unsigned long long rrdset_done(RRDSET *st)
     unsigned int
         stored_entries = 0;     // the number of entries we have stored in the db, during this call to rrdset_done()
 
-    unsigned long long
+    usec_t
         last_collect_ut,        // the timestamp in microseconds, of the last collected value
         now_collect_ut,         // the timestamp in microseconds, of this collected value (this is NOW)
         last_stored_ut,         // the timestamp in microseconds, of the last stored entry in the db
         next_store_ut,          // the timestamp in microseconds, of the next entry to store in the db
-        update_every_ut = st->update_every * 1000000ULL; // st->update_every in microseconds
+        update_every_ut = st->update_every * USEC_PER_SEC; // st->update_every in microseconds
 
     if(unlikely(pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, &pthreadoldcancelstate) != 0))
         error("Cannot set pthread cancel state to DISABLE.");
@@ -1105,7 +1105,7 @@ unsigned long long rrdset_done(RRDSET *st)
         now_realtime_timeval(&st->last_collected_time);
         timeval_align(&st->last_collected_time, st->update_every);
 
-        last_collect_ut = st->last_collected_time.tv_sec * 1000000ULL + st->last_collected_time.tv_usec - update_every_ut;
+        last_collect_ut = st->last_collected_time.tv_sec * USEC_PER_SEC + st->last_collected_time.tv_usec - update_every_ut;
 
         // the first entry should not be stored
         store_this_entry = 0;
@@ -1116,10 +1116,10 @@ unsigned long long rrdset_done(RRDSET *st)
     else {
         // it is not the first entry
         // calculate the proper last_collected_time, using usec_since_last_update
-        last_collect_ut = st->last_collected_time.tv_sec * 1000000ULL + st->last_collected_time.tv_usec;
-        unsigned long long ut = last_collect_ut + st->usec_since_last_update;
-        st->last_collected_time.tv_sec = (time_t) (ut / 1000000ULL);
-        st->last_collected_time.tv_usec = (suseconds_t) (ut % 1000000ULL);
+        last_collect_ut = st->last_collected_time.tv_sec * USEC_PER_SEC + st->last_collected_time.tv_usec;
+        usec_t ut = last_collect_ut + st->usec_since_last_update;
+        st->last_collected_time.tv_sec = (time_t) (ut / USEC_PER_SEC);
+        st->last_collected_time.tv_usec = (suseconds_t) (ut % USEC_PER_SEC);
     }
 
     // if this set has not been updated in the past
@@ -1127,9 +1127,9 @@ unsigned long long rrdset_done(RRDSET *st)
     if(unlikely(!st->last_updated.tv_sec)) {
         // it has never been updated before
         // set a fake last_updated, in the past using usec_since_last_update
-        unsigned long long ut = st->last_collected_time.tv_sec * 1000000ULL + st->last_collected_time.tv_usec - st->usec_since_last_update;
-        st->last_updated.tv_sec = (time_t) (ut / 1000000ULL);
-        st->last_updated.tv_usec = (suseconds_t) (ut % 1000000ULL);
+        usec_t ut = st->last_collected_time.tv_sec * USEC_PER_SEC + st->last_collected_time.tv_usec - st->usec_since_last_update;
+        st->last_updated.tv_sec = (time_t) (ut / USEC_PER_SEC);
+        st->last_updated.tv_usec = (suseconds_t) (ut % USEC_PER_SEC);
 
         // the first entry should not be stored
         store_this_entry = 0;
@@ -1148,9 +1148,9 @@ unsigned long long rrdset_done(RRDSET *st)
         now_realtime_timeval(&st->last_collected_time);
         timeval_align(&st->last_collected_time, st->update_every);
 
-        unsigned long long ut = st->last_collected_time.tv_sec * 1000000ULL + st->last_collected_time.tv_usec - st->usec_since_last_update;
-        st->last_updated.tv_sec = (time_t) (ut / 1000000ULL);
-        st->last_updated.tv_usec = (suseconds_t) (ut % 1000000ULL);
+        usec_t ut = st->last_collected_time.tv_sec * USEC_PER_SEC + st->last_collected_time.tv_usec - st->usec_since_last_update;
+        st->last_updated.tv_sec = (time_t) (ut / USEC_PER_SEC);
+        st->last_updated.tv_usec = (suseconds_t) (ut % USEC_PER_SEC);
 
         // the first entry should not be stored
         store_this_entry = 0;
@@ -1161,9 +1161,9 @@ unsigned long long rrdset_done(RRDSET *st)
     // last_stored_ut = the last time we added a value to the storage
     // now_collect_ut = the time the current value has been collected
     // next_store_ut  = the time of the next interpolation point
-    last_stored_ut = st->last_updated.tv_sec * 1000000ULL + st->last_updated.tv_usec;
-    now_collect_ut = st->last_collected_time.tv_sec * 1000000ULL + st->last_collected_time.tv_usec;
-    next_store_ut  = (st->last_updated.tv_sec + st->update_every) * 1000000ULL;
+    last_stored_ut = st->last_updated.tv_sec * USEC_PER_SEC + st->last_updated.tv_usec;
+    now_collect_ut = st->last_collected_time.tv_sec * USEC_PER_SEC + st->last_collected_time.tv_usec;
+    next_store_ut  = (st->last_updated.tv_sec + st->update_every) * USEC_PER_SEC;
 
     if(unlikely(st->debug)) {
         debug(D_RRD_STATS, "%s: last_collect_ut = %0.3Lf (last collection time)", st->name, (long double)last_collect_ut/1000000.0);
@@ -1366,7 +1366,7 @@ unsigned long long rrdset_done(RRDSET *st)
 #endif
     }
 
-    unsigned long long first_ut = last_stored_ut;
+    usec_t first_ut = last_stored_ut;
     long long iterations = (now_collect_ut - last_stored_ut) / (update_every_ut);
     if((now_collect_ut % (update_every_ut)) == 0) iterations++;
 
@@ -1380,7 +1380,7 @@ unsigned long long rrdset_done(RRDSET *st)
             debug(D_RRD_STATS, "%s: next_store_ut  = %0.3Lf (next interpolation point)", st->name, (long double)next_store_ut/1000000.0);
         }
 
-        st->last_updated.tv_sec = (time_t) (next_store_ut / 1000000ULL);
+        st->last_updated.tv_sec = (time_t) (next_store_ut / USEC_PER_SEC);
         st->last_updated.tv_usec = 0;
 
         for( rd = st->dimensions ; likely(rd) ; rd = rd->next ) {

diff --git a/src/rrd.h b/src/rrd.h
index f0d86540ddd62bb321438b4df7b229cde17d0c68..dbaf986503675fde06923ddc66d01024e08c5b23 100644 (file)
--- a/src/rrd.h
+++ b/src/rrd.h
@@ -244,7 +244,7 @@ struct rrdset {
 
     uint32_t hash_name;                             // a simple hash on the name
 
-    unsigned long long usec_since_last_update;      // the time in microseconds since the last collection of data
+    usec_t usec_since_last_update;                  // the time in microseconds since the last collection of data
 
     struct timeval last_updated;                    // when this data set was last updated (updated every time the rrd_stats_done() function)
     struct timeval last_collected_time;             // when did this data set last collected values
@@ -355,11 +355,11 @@ extern RRDSET *rrdset_find(const char *id);
 extern RRDSET *rrdset_find_bytype(const char *type, const char *id);
 extern RRDSET *rrdset_find_byname(const char *name);
 
-extern void rrdset_next_usec_unfiltered(RRDSET *st, unsigned long long microseconds);
-extern void rrdset_next_usec(RRDSET *st, unsigned long long microseconds);
+extern void rrdset_next_usec_unfiltered(RRDSET *st, usec_t microseconds);
+extern void rrdset_next_usec(RRDSET *st, usec_t microseconds);
 #define rrdset_next(st) rrdset_next_usec(st, 0ULL)
 
-extern unsigned long long rrdset_done(RRDSET *st);
+extern usec_t rrdset_done(RRDSET *st);
 
 // get the total duration in seconds of the round robin database
 #define rrdset_duration(st) ((time_t)( (((st)->counter >= ((unsigned long)(st)->entries))?(unsigned long)(st)->entries:(st)->counter) * (st)->update_every ))

diff --git a/src/sys_fs_cgroup.c b/src/sys_fs_cgroup.c
index 718231ccb3a3b9231915dc7258cae1a5b9feddb3..a42178efc3188d14f406880460a712d7a62e7d2d 100644 (file)
--- a/src/sys_fs_cgroup.c
+++ b/src/sys_fs_cgroup.c
@@ -1391,7 +1391,7 @@ void update_cgroup_charts(int update_every) {
 // ----------------------------------------------------------------------------
 // cgroups main
 
-int do_sys_fs_cgroup(int update_every, unsigned long long dt) {
+int do_sys_fs_cgroup(int update_every, usec_t dt) {
     (void)dt;
 
     static int cgroup_global_config_read = 0;
@@ -1433,15 +1433,15 @@ void *cgroups_main(void *ptr)
     int vdo_cpu_netdata             = !config_get_boolean("plugin:cgroups", "cgroups plugin resources", 1);
 
     // keep track of the time each module was called
-    unsigned long long sutime_sys_fs_cgroup = 0ULL;
+    usec_t sutime_sys_fs_cgroup = 0ULL;
 
     // the next time we will run - aligned properly
-    unsigned long long sunext = (now_realtime_sec() - (now_realtime_sec() % rrd_update_every) + rrd_update_every) * 1000000ULL;
+    usec_t sunext = (now_realtime_sec() - (now_realtime_sec() % rrd_update_every) + rrd_update_every) * USEC_PER_SEC;
 
     RRDSET *stcpu_thread = NULL;
 
     for(;;) {
-        unsigned long long sunow;
+        usec_t sunow;
         if(unlikely(netdata_exit)) break;
 
         // delay until it is our time to run
@@ -1450,7 +1450,7 @@ void *cgroups_main(void *ptr)
 
         // find the next time we need to run
         while(now_realtime_usec() > sunext)
-            sunext += rrd_update_every * 1000000ULL;
+            sunext += rrd_update_every * USEC_PER_SEC;
 
         if(unlikely(netdata_exit)) break;
 

diff --git a/src/sys_kernel_mm_ksm.c b/src/sys_kernel_mm_ksm.c
index 8c51be1df5e0b08337b61656d2682634eefdf35f..727bca3e575b2622264fade50e8d7c2d990e7526 100644 (file)
--- a/src/sys_kernel_mm_ksm.c
+++ b/src/sys_kernel_mm_ksm.c
@@ -19,7 +19,7 @@ KSM_NAME_VALUE values[] = {
         [PAGES_TO_SCAN] = { "/sys/kernel/mm/ksm/pages_to_scan", 0ULL },
 };
 
-int do_sys_kernel_mm_ksm(int update_every, unsigned long long dt) {
+int do_sys_kernel_mm_ksm(int update_every, usec_t dt) {
     static procfile *ff_pages_shared = NULL, *ff_pages_sharing = NULL, *ff_pages_unshared = NULL, *ff_pages_volatile = NULL, *ff_pages_to_scan = NULL;
     static long page_size = -1;