Merging upstream version 1.18.1.

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

11 files changed, 277 insertions, 36 deletions

diff --git a/libnetdata/Makefile.am b/libnetdata/Makefile.am
index 87f12b32c..7dc808fab 100644
--- a/libnetdata/Makefile.am
+++ b/libnetdata/Makefile.am
@@ -23,6 +23,7 @@ SUBDIRS = \
     storage_number \
     threads \
     url \
+    tests \
     $(NULL)
 
 dist_noinst_DATA = \
diff --git a/libnetdata/health/health.c b/libnetdata/health/health.c
index a70f284b1..e03538db3 100644
--- a/libnetdata/health/health.c
+++ b/libnetdata/health/health.c
@@ -112,7 +112,7 @@ int health_silencers_json_read_callback(JSON_ENTRY *e)
         case JSON_OBJECT:
 #ifndef ENABLE_JSONC
             e->callback_function = health_silencers_json_read_callback;
-            if(e->name && strcmp(e->name,"")) {
+            if(strcmp(e->name,"")) {
                 // init silencer
                 debug(D_HEALTH, "JSON: Got object with a name, initializing new silencer for %s",e->name);
 #endif
diff --git a/libnetdata/json/json.c b/libnetdata/json/json.c
index 7c5adca3d..3ccc561c6 100644
--- a/libnetdata/json/json.c
+++ b/libnetdata/json/json.c
@@ -284,18 +284,13 @@ size_t json_walk_primitive(char *js, jsmntok_t *t, size_t start, JSON_ENTRY *e)
  * @param t the tokens
  * @param nest the length of structure t
  * @param start the first position
- * @param e the output structure.
+ * @param e the structure with values and callback to be used inside the function.
  *
  * @return It returns the array length
  */
 size_t json_walk_array(char *js, jsmntok_t *t, size_t nest, size_t start, JSON_ENTRY *e)
 {
-    JSON_ENTRY ne = {
-            .name = "",
-            .fullname = "",
-            .callback_data = NULL,
-            .callback_function = NULL
-    };
+    JSON_ENTRY ne;
 
     char old = js[t[start].end];
     js[t[start].end] = '\0';
@@ -315,7 +310,7 @@ size_t json_walk_array(char *js, jsmntok_t *t, size_t nest, size_t start, JSON_E
     start++;
     for(i = 0; i < size ; i++) {
         ne.pos = i;
-        if (!e->name || !e->fullname || strlen(e->name) > JSON_NAME_LEN  - 24 || strlen(e->fullname) > JSON_FULLNAME_LEN -24) {
+        if (strlen(e->name) > JSON_NAME_LEN  - 24 || strlen(e->fullname) > JSON_FULLNAME_LEN -24) {
             info("JSON: JSON walk_array ignoring element with name:%s fullname:%s",e->name, e->fullname);
             continue;
         }
diff --git a/libnetdata/popen/popen.c b/libnetdata/popen/popen.c
index 906b10535..1c4ae64d6 100644
--- a/libnetdata/popen/popen.c
+++ b/libnetdata/popen/popen.c
@@ -2,46 +2,79 @@
 
 #include "../libnetdata.h"
 
-/*
+static pthread_mutex_t myp_lock;
+static int myp_tracking = 0;
+
 struct mypopen {
     pid_t pid;
-    FILE *fp;
     struct mypopen *next;
     struct mypopen *prev;
 };
 
 static struct mypopen *mypopen_root = NULL;
 
-static void mypopen_add(FILE *fp, pid_t *pid) {
-    struct mypopen *mp = malloc(sizeof(struct mypopen));
-    if(!mp) {
-        fatal("Cannot allocate %zu bytes", sizeof(struct mypopen))
+// myp_add_lock takes the lock if we're tracking.
+static void myp_add_lock(void) {
+    if (myp_tracking == 0)
         return;
-    }
 
-    mp->fp = fp;
+    netdata_mutex_lock(&myp_lock);
+}
+
+// myp_add_unlock release the lock if we're tracking.
+static void myp_add_unlock(void) {
+    if (myp_tracking == 0)
+        return;
+
+    netdata_mutex_unlock(&myp_lock);
+}
+
+// myp_add_locked adds pid if we're tracking.
+// myp_add_lock must have been called previously.
+static void myp_add_locked(pid_t pid) {
+    struct mypopen *mp;
+
+    if (myp_tracking == 0)
+        return;
+
+    mp = mallocz(sizeof(struct mypopen));
     mp->pid = pid;
-    mp->next = popen_root;
+
+    mp->next = mypopen_root;
     mp->prev = NULL;
-    if(mypopen_root) mypopen_root->prev = mp;
+    if (mypopen_root != NULL)
+        mypopen_root->prev = mp;
     mypopen_root = mp;
+    netdata_mutex_unlock(&myp_lock);
 }
 
-static void mypopen_del(FILE *fp) {
+// myp_del deletes pid if we're tracking.
+static void myp_del(pid_t pid) {
     struct mypopen *mp;
 
-    for(mp = mypopen_root; mp; mp = mp->next)
-        if(mp->fd == fp) break;
+    if (myp_tracking == 0)
+        return;
 
-    if(!mp) error("Cannot find mypopen() file pointer in open childs.");
-    else {
-        if(mp->next) mp->next->prev = mp->prev;
-        if(mp->prev) mp->prev->next = mp->next;
-        if(mypopen_root == mp) mypopen_root = mp->next;
-        free(mp);
+    netdata_mutex_lock(&myp_lock);
+    for (mp = mypopen_root; mp != NULL; mp = mp->next) {
+        if (mp->pid == pid) {
+            if (mp->next != NULL)
+                mp->next->prev = mp->prev;
+            if (mp->prev != NULL)
+                mp->prev->next = mp->next;
+            if (mypopen_root == mp)
+                mypopen_root = mp->next;
+            freez(mp);
+            break;
+        }
     }
+
+    if (mp == NULL)
+        error("Cannot find pid %d.", pid);
+
+    netdata_mutex_unlock(&myp_lock);
 }
-*/
+
 #define PIPE_READ 0
 #define PIPE_WRITE 1
 
@@ -58,7 +91,7 @@ static inline FILE *custom_popene(const char *command, volatile pid_t *pidptr, c
     posix_spawnattr_t attr;
     posix_spawn_file_actions_t fa;
 
-    if(pipe(pipefd) == -1)
+    if (pipe(pipefd) == -1)
         return NULL;
     if ((fp = fdopen(pipefd[PIPE_READ], "r")) == NULL) {
         goto error_after_pipe;
@@ -66,7 +99,7 @@ static inline FILE *custom_popene(const char *command, volatile pid_t *pidptr, c
 
     // Mark all files to be closed by the exec() stage of posix_spawn()
     int i;
-    for(i = (int) (sysconf(_SC_OPEN_MAX) - 1); i >= 0; i--)
+    for (i = (int) (sysconf(_SC_OPEN_MAX) - 1); i >= 0; i--)
         if(i != STDIN_FILENO && i != STDERR_FILENO)
             (void)fcntl(i, F_SETFD, FD_CLOEXEC);
 
@@ -92,10 +125,16 @@ static inline FILE *custom_popene(const char *command, volatile pid_t *pidptr, c
     } else {
         error("posix_spawnattr_init() failed.");
     }
+
+    // Take the lock while we fork to ensure we don't race with SIGCHLD
+    // delivery on a process which exits quickly.
+    myp_add_lock();
     if (!posix_spawn(&pid, "/bin/sh", &fa, &attr, spawn_argv, env)) {
         *pidptr = pid;
+        myp_add_locked(pid);
         debug(D_CHILDS, "Spawned command: '%s' on pid %d from parent pid %d.", command, pid, getpid());
     } else {
+        myp_add_unlock();
         error("Failed to spawn command: '%s' from parent pid %d.", command, getpid());
         fclose(fp);
         fp = NULL;
@@ -128,6 +167,60 @@ error_after_pipe:
 // See man environ
 extern char **environ;
 
+// myp_init should be called by apps which act as init
+// (pid 1) so that processes created by mypopen and mypopene
+// are tracked. This enables the reaper to ignore processes
+// which will be handled internally, by calling myp_reap, to
+// avoid issues with already reaped processes during wait calls.
+//
+// Callers should call myp_free() to clean up resources.
+void myp_init(void) {
+    info("process tracking enabled.");
+    myp_tracking = 1;
+
+    if (netdata_mutex_init(&myp_lock) != 0) {
+	fatal("myp_init() mutex init failed.");
+    }
+}
+
+// myp_free cleans up any resources allocated for process
+// tracking.
+void myp_free(void) {
+    struct mypopen *mp, *next;
+
+    if (myp_tracking == 0)
+        return;
+
+    netdata_mutex_lock(&myp_lock);
+    for (mp = mypopen_root; mp != NULL; mp = next) {
+        next = mp->next;
+        freez(mp);
+    }
+
+    mypopen_root = NULL;
+    myp_tracking = 0;
+    netdata_mutex_unlock(&myp_lock);
+}
+
+// myp_reap returns 1 if pid should be reaped, 0 otherwise.
+int myp_reap(pid_t pid) {
+    struct mypopen *mp;
+
+    if (myp_tracking == 0)
+        return 0;
+
+    netdata_mutex_lock(&myp_lock);
+    for (mp = mypopen_root; mp != NULL; mp = mp->next) {
+        if (mp->pid == pid) {
+            netdata_mutex_unlock(&myp_lock);
+            return 0;
+        }
+    }
+    netdata_mutex_unlock(&myp_lock);
+
+    return 1;
+}
+
 FILE *mypopen(const char *command, volatile pid_t *pidptr) {
     return custom_popene(command, pidptr, environ);
 }
@@ -137,9 +230,10 @@ FILE *mypopene(const char *command, volatile pid_t *pidptr, char **env) {
 }
 
 int mypclose(FILE *fp, pid_t pid) {
-    debug(D_EXIT, "Request to mypclose() on pid %d", pid);
+    int ret;
+    siginfo_t info;
 
-    /*mypopen_del(fp);*/
+    debug(D_EXIT, "Request to mypclose() on pid %d", pid);
 
     // close the pipe fd
     // this is required in musl
@@ -151,9 +245,11 @@ int mypclose(FILE *fp, pid_t pid) {
 
     errno = 0;
 
-    siginfo_t info;
-    if(waitid(P_PID, (id_t) pid, &info, WEXITED) != -1) {
-        switch(info.si_code) {
+    ret = waitid(P_PID, (id_t) pid, &info, WEXITED);
+    myp_del(pid);
+
+    if (ret != -1) {
+        switch (info.si_code) {
             case CLD_EXITED:
                 if(info.si_status)
                     error("child pid %d exited with code %d.", info.si_pid, info.si_status);
diff --git a/libnetdata/popen/popen.h b/libnetdata/popen/popen.h
index 90d4b829b..32f64e460 100644
--- a/libnetdata/popen/popen.h
+++ b/libnetdata/popen/popen.h
@@ -11,6 +11,9 @@
 extern FILE *mypopen(const char *command, volatile pid_t *pidptr);
 extern FILE *mypopene(const char *command, volatile pid_t *pidptr, char **env);
 extern int mypclose(FILE *fp, pid_t pid);
+extern void myp_init(void);
+extern void myp_free(void);
+extern int myp_reap(pid_t pid);
 
 extern void signals_unblock(void);
 extern void signals_reset(void);
diff --git a/libnetdata/required_dummies.h b/libnetdata/required_dummies.h
new file mode 100644
index 000000000..aa87e3964
--- /dev/null
+++ b/libnetdata/required_dummies.h
@@ -0,0 +1,38 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+#ifndef NETDATA_LIB_DUMMIES_H
+#define NETDATA_LIB_DUMMIES_H 1
+
+// callback required by fatal()
+void netdata_cleanup_and_exit(int ret)
+{
+    exit(ret);
+}
+
+void send_statistics(const char *action, const char *action_result, const char *action_data)
+{
+    (void)action;
+    (void)action_result;
+    (void)action_data;
+    return;
+}
+
+// callbacks required by popen()
+void signals_block(void){};
+void signals_unblock(void){};
+void signals_reset(void){};
+
+// callback required by eval()
+int health_variable_lookup(const char *variable, uint32_t hash, struct rrdcalc *rc, calculated_number *result)
+{
+    (void)variable;
+    (void)hash;
+    (void)rc;
+    (void)result;
+    return 0;
+};
+
+// required by get_system_cpus()
+char *netdata_configured_host_prefix = "";
+
+#endif // NETDATA_LIB_DUMMIES_H
diff --git a/libnetdata/storage_number/Makefile.am b/libnetdata/storage_number/Makefile.am
index 1cb69ed99..349dd71f1 100644
--- a/libnetdata/storage_number/Makefile.am
+++ b/libnetdata/storage_number/Makefile.am
@@ -3,6 +3,9 @@
 AUTOMAKE_OPTIONS = subdir-objects
 MAINTAINERCLEANFILES = $(srcdir)/Makefile.in
 
+SUBDIRS = \
+	tests \
+	$(NULL)
 
 dist_noinst_DATA = \
 	README.md \
diff --git a/libnetdata/storage_number/tests/Makefile.am b/libnetdata/storage_number/tests/Makefile.am
new file mode 100644
index 000000000..babdcf0df
--- /dev/null
+++ b/libnetdata/storage_number/tests/Makefile.am
@@ -0,0 +1,4 @@
+# SPDX-License-Identifier: GPL-3.0-or-later
+
+AUTOMAKE_OPTIONS = subdir-objects
+MAINTAINERCLEANFILES = $(srcdir)/Makefile.in
diff --git a/libnetdata/storage_number/tests/test_storage_number.c b/libnetdata/storage_number/tests/test_storage_number.c
new file mode 100644
index 000000000..61a0c1880
--- /dev/null
+++ b/libnetdata/storage_number/tests/test_storage_number.c
@@ -0,0 +1,49 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+#include "../../libnetdata.h"
+#include "../../required_dummies.h"
+#include <setjmp.h>
+#include <cmocka.h>
+
+static void test_number_pinting(void **state)
+{
+    (void)state;
+
+    char value[50];
+
+    print_calculated_number(value, 0);
+    assert_string_equal(value, "0");
+
+    print_calculated_number(value, 0.0000001);
+    assert_string_equal(value, "0.0000001");
+
+    print_calculated_number(value, 0.00000009);
+    assert_string_equal(value, "0.0000001");
+
+    print_calculated_number(value, 0.000000001);
+    assert_string_equal(value, "0");
+
+    print_calculated_number(value, 99.99999999999999999);
+    assert_string_equal(value, "100");
+
+    print_calculated_number(value, -99.99999999999999999);
+    assert_string_equal(value, "-100");
+
+    print_calculated_number(value, 123.4567890123456789);
+    assert_string_equal(value, "123.456789");
+
+    print_calculated_number(value, 9999.9999999);
+    assert_string_equal(value, "9999.9999999");
+
+    print_calculated_number(value, -9999.9999999);
+    assert_string_equal(value, "-9999.9999999");
+}
+
+int main(void)
+{
+    const struct CMUnitTest tests[] = {
+        cmocka_unit_test(test_number_pinting)
+    };
+
+    return cmocka_run_group_tests_name("storage_number", tests, NULL, NULL);
+}
diff --git a/libnetdata/tests/Makefile.am b/libnetdata/tests/Makefile.am
new file mode 100644
index 000000000..babdcf0df
--- /dev/null
+++ b/libnetdata/tests/Makefile.am
@@ -0,0 +1,4 @@
+# SPDX-License-Identifier: GPL-3.0-or-later
+
+AUTOMAKE_OPTIONS = subdir-objects
+MAINTAINERCLEANFILES = $(srcdir)/Makefile.in
diff --git a/libnetdata/tests/test_str2ld.c b/libnetdata/tests/test_str2ld.c
new file mode 100644
index 000000000..9d59f6c0e
--- /dev/null
+++ b/libnetdata/tests/test_str2ld.c
@@ -0,0 +1,48 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+#include "../libnetdata.h"
+#include "../required_dummies.h"
+#include <setjmp.h>
+#include <cmocka.h>
+
+static void test_str2ld(void **state)
+{
+    (void)state;
+    char *values[] = {
+        "1.2345678",
+        "-35.6",
+        "0.00123",
+        "23842384234234.2",
+        ".1",
+        "1.2e-10",
+        "hello",
+        "1wrong",
+        "nan",
+        "inf",
+        NULL
+    };
+
+    for (int i = 0; values[i]; i++) {
+        char *e_mine = "hello", *e_sys = "world";
+        LONG_DOUBLE mine = str2ld(values[i], &e_mine);
+        LONG_DOUBLE sys = strtold(values[i], &e_sys);
+
+        if (isnan(mine))
+            assert_true(isnan(sys));
+        else if (isinf(mine))
+            assert_true(isinf(sys));
+        else if (mine != sys)
+            assert_false(abs(mine - sys) > 0.000001);
+
+        assert_ptr_equal(e_mine, e_sys);
+    }
+}
+
+int main(void)
+{
+    const struct CMUnitTest tests[] = {
+        cmocka_unit_test(test_str2ld)
+    };
+
+    return cmocka_run_group_tests_name("str2ld", tests, NULL, NULL);
+}