[pull] master from netdata:master

CHANGELOG.md

@@ -6,6 +6,7 @@
 
 **Merged pull requests:**
 
+- fix runtime directory; annotate daemon status file [\#19706](https://github.com/netdata/netdata/pull/19706) ([ktsaou](https://github.com/ktsaou))
 - add host/os fields to status file [\#19704](https://github.com/netdata/netdata/pull/19704) ([ktsaou](https://github.com/ktsaou))
 - under MSYS2 use stat [\#19703](https://github.com/netdata/netdata/pull/19703) ([ktsaou](https://github.com/ktsaou))
 - Document journal v2 index file format. [\#19701](https://github.com/netdata/netdata/pull/19701) ([vkalintiris](https://github.com/vkalintiris))

packaging/version

@@ -1 +1 @@
-v2.2.0-245-nightly
+v2.2.0-247-nightly

src/claim/claim-with-api.c

@@ -372,7 +372,7 @@ bool claim_agent(const char *url, const char *token, const char *rooms, const ch
     bool done = false, can_retry = true;
     size_t retries = 0;
     do {
-        done = send_curl_request(registry_get_this_machine_guid(), registry_get_this_machine_hostname(), token, rooms, url, proxy, insecure, &can_retry);
+        done = send_curl_request(registry_get_this_machine_guid(true), registry_get_this_machine_hostname(), token, rooms, url, proxy, insecure, &can_retry);
         if (done) break;
         sleep_usec(300 * USEC_PER_MS + 100 * retries * USEC_PER_MS);
         retries++;

src/claim/cloud-conf.c

@@ -79,7 +79,7 @@ void cloud_conf_init_after_registry(void) {
 
     // for machine guid and hostname we have to use inicfg_set() for that they will be saved uncommented
     if(!machine_guid || !*machine_guid)
-        inicfg_set(&cloud_config, CONFIG_SECTION_GLOBAL, "machine_guid", registry_get_this_machine_guid());
+        inicfg_set(&cloud_config, CONFIG_SECTION_GLOBAL, "machine_guid", registry_get_this_machine_guid(true));
 
     if(!hostname || !*hostname)
         inicfg_set(&cloud_config, CONFIG_SECTION_GLOBAL, "hostname", registry_get_this_machine_hostname());

src/daemon/daemon-status-file.c

@@ -263,7 +263,7 @@ static DAEMON_STATUS_FILE daemon_status_file_get(DAEMON_STATUS status) {
     else if(!UUIDiszero(last_session_status.host_id))
         session_status.host_id = last_session_status.host_id;
     else {
-        const char *machine_guid = registry_get_this_machine_guid();
+        const char *machine_guid = registry_get_this_machine_guid(false);
         if(machine_guid && *machine_guid) {
             if (uuid_parse_flexi(machine_guid, session_status.host_id.uuid) != 0)
                 session_status.host_id = UUID_ZERO;
@@ -296,8 +296,7 @@ static DAEMON_STATUS_FILE daemon_status_file_get(DAEMON_STATUS status) {
     if(!session_status.os_id_like && last_session_status.os_id_like)
         session_status.os_id_like = strdupz(last_session_status.os_id_like);
 
-    if((session_status.status == DAEMON_STATUS_NONE && !session_status.architecture) || status == DAEMON_STATUS_RUNNING)
-        get_daemon_status_fields_from_system_info(&session_status);
+    get_daemon_status_fields_from_system_info(&session_status);
 
     session_status.exit_reason = exit_initiated;
     session_status.profile = nd_profile_detect_and_configure(false);
@@ -373,7 +372,7 @@ DAEMON_STATUS_FILE daemon_status_file_load(void) {
     char current_filename[FILENAME_MAX];
     time_t newest_mtime = 0, current_mtime;
 
-    // Check primary directory first
+    // Check the primary directory first
     if(check_status_file(netdata_configured_cache_dir, current_filename, sizeof(current_filename), &current_mtime)) {
         strncpyz(newest_filename, current_filename, sizeof(newest_filename) - 1);
         newest_mtime = current_mtime;
@@ -529,7 +528,7 @@ void *post_status_file_thread(void *ptr) {
 }
 
 // --------------------------------------------------------------------------------------------------------------------
-// check last status on startup and post crash report
+// check last status on startup and post-crash report
 
 void daemon_status_file_check_crash(void) {
     last_session_status = daemon_status_file_load();
@@ -583,8 +582,20 @@ void daemon_status_file_check_crash(void) {
             break;
 
         case DAEMON_STATUS_INITIALIZING:
-            cause = "crashed on start";
-            msg = "Netdata was last killed/crashed while starting";
+            if (OS_SYSTEM_DISK_SPACE_OK(last_session_status.var_cache) &&
+                last_session_status.var_cache.is_read_only) {
+                cause = "disk read-only";
+                msg = "Netdata couldn't start because the disk is readonly";
+            }
+            else if (OS_SYSTEM_DISK_SPACE_OK(last_session_status.var_cache) &&
+                last_session_status.var_cache.free_bytes == 0) {
+                cause = "disk full";
+                msg = "Netdata couldn't start because the disk is full";
+            }
+            else {
+                cause = "crashed on start";
+                msg = "Netdata was last killed/crashed while starting";
+            }
             pri = NDLP_ERR;
             post_crash_report = true;
             break;
@@ -663,14 +674,22 @@ bool daemon_status_file_was_incomplete_shutdown(void) {
     return last_session_status.status == DAEMON_STATUS_EXITING;
 }
 
+void daemon_status_file_startup_step(const char *step) {
+    freez((char *)session_status.fatal.function);
+    session_status.fatal.function = strdupz(step);
+    if(step != NULL)
+        daemon_status_file_save(DAEMON_STATUS_NONE);
+}
+
 // --------------------------------------------------------------------------------------------------------------------
 // ng_log() hook for receiving fatal message information
 
 void daemon_status_file_register_fatal(const char *filename, const char *function, const char *message, const char *stack_trace, long line) {
     static SPINLOCK spinlock = SPINLOCK_INITIALIZER;
     spinlock_lock(&spinlock);
 
-    if(session_status.fatal.filename || session_status.fatal.function || session_status.fatal.message || session_status.fatal.stack_trace) {
+    // do not check the function, because it may have a startup step in it
+    if(session_status.fatal.filename || session_status.fatal.message || session_status.fatal.stack_trace) {
         spinlock_unlock(&spinlock);
         freez((void *)filename);
         freez((void *)function);
@@ -680,6 +699,7 @@ void daemon_status_file_register_fatal(const char *filename, const char *functio
     }
 
     session_status.fatal.filename = filename;
+    freez((char *)session_status.fatal.function); // it may have a startup step
     session_status.fatal.function = function;
     session_status.fatal.message = message;
     session_status.fatal.stack_trace = stack_trace;

src/daemon/daemon-status-file.h

@@ -79,6 +79,7 @@ void daemon_status_file_check_crash(void);
 
 bool daemon_status_file_has_last_crashed(void);
 bool daemon_status_file_was_incomplete_shutdown(void);
+void daemon_status_file_startup_step(const char *step);
 
 void daemon_status_file_register_fatal(const char *filename, const char *function, const char *message, const char *stack_trace, long line);
 

src/daemon/daemon.h

@@ -10,4 +10,6 @@ void get_netdata_execution_path(void);
 extern char *pidfile;
 extern char *netdata_exe_path;
 
+void verify_required_directory(const char *env, const char *dir, bool create_it, int perms);
+
 #endif /* NETDATA_DAEMON_H */

src/daemon/environment.c

@@ -2,35 +2,57 @@
 
 #include "common.h"
 
-static const char *verify_required_directory(const char *dir)
-{
-    if (chdir(dir) == -1)
-        fatal("Cannot change directory to '%s'", dir);
+void verify_required_directory(const char *env, const char *dir, bool create_it, int perms) {
+    errno_clear();
 
-    DIR *d = opendir(dir);
-    if (!d)
-        fatal("Cannot examine the contents of directory '%s'", dir);
-    closedir(d);
+    if (!dir || *dir != '/')
+        fatal("Invalid directory path (must be an absolute path): '%s'\n", dir);
 
-    return dir;
-}
+    if (chdir(dir) == 0) {
+        if(env)
+            nd_setenv(env, dir, 1);
+        return;
+    }
 
-static const char *verify_or_create_required_directory(const char *dir) {
-    errno_clear();
+    if(create_it) {
+        if(mkdir(dir, perms) == 0) {
+            if(env)
+                nd_setenv(env, dir, 1);
+            return;
+        }
+    }
 
-    if (mkdir(dir, 0755) != 0 && errno != EEXIST)
-        fatal("Cannot create required directory '%s'", dir);
+    char path[PATH_MAX];
+    strncpyz(path, dir, sizeof(path) - 1);
+    struct stat st;
 
-    return verify_required_directory(dir);
-}
+    char *p = path;
+    while (*p) {
+        if (p != path && *p == '/') {
+            *p = '\0';
 
-static const char *verify_or_create_required_private_directory(const char *dir) {
-    errno_clear();
+            errno_clear();
+            if (stat(path, &st) == -1)
+                fatal("Required directory: '%s' - Missing or inaccessible component: '%s' (error: %s)\n", dir, path, strerror(errno));
+
+            if (!S_ISDIR(st.st_mode))
+                fatal("Required directory: '%s' - Component '%s' exists but is not a directory.\n", dir, path);
+
+            *p = '/';
+        }
+        p++;
+    }
+
+    if (stat(dir, &st) == -1)
+        fatal("Required directory: '%s' - Missing or inaccessible: '%s' (error: %s)\n", dir, dir, strerror(errno));
+
+    if (!S_ISDIR(st.st_mode))
+        fatal("Required directory: '%s' - '%s' exists but is not a directory.\n", dir, dir);
 
-    if (mkdir(dir, 0770) != 0 && errno != EEXIST)
-        fatal("Cannot create required directory '%s'", dir);
+    if (access(dir, R_OK | X_OK) == -1)
+        fatal("Required directory: '%s' - Insufficient permissions for: '%s' (error: %s)\n", dir, dir, strerror(errno));
 
-    return verify_required_directory(dir);
+    fatal("Required directory: '%s' - Failed (error: %s)\n", dir, strerror(errno));
 }
 
 void set_environment_for_plugins_and_scripts(void) {
@@ -42,17 +64,17 @@ void set_environment_for_plugins_and_scripts(void) {
 
     nd_setenv("NETDATA_VERSION", NETDATA_VERSION, 1);
     nd_setenv("NETDATA_HOSTNAME", netdata_configured_hostname, 1);
-    nd_setenv("NETDATA_CONFIG_DIR", verify_required_directory(netdata_configured_user_config_dir), 1);
-    nd_setenv("NETDATA_USER_CONFIG_DIR", verify_required_directory(netdata_configured_user_config_dir), 1);
-    nd_setenv("NETDATA_STOCK_CONFIG_DIR", verify_required_directory(netdata_configured_stock_config_dir), 1);
-    nd_setenv("NETDATA_PLUGINS_DIR", verify_required_directory(netdata_configured_primary_plugins_dir), 1);
-    nd_setenv("NETDATA_WEB_DIR", verify_required_directory(netdata_configured_web_dir), 1);
-    nd_setenv("NETDATA_CACHE_DIR", verify_or_create_required_directory(netdata_configured_cache_dir), 1);
-    nd_setenv("NETDATA_LIB_DIR", verify_or_create_required_directory(netdata_configured_varlib_dir), 1);
-    nd_setenv("NETDATA_LOG_DIR", verify_or_create_required_directory(netdata_configured_log_dir), 1);
     nd_setenv("NETDATA_HOST_PREFIX", netdata_configured_host_prefix, 1);
 
-    nd_setenv("CLAIMING_DIR", verify_or_create_required_private_directory(netdata_configured_cloud_dir), 1);
+    verify_required_directory("NETDATA_CONFIG_DIR", netdata_configured_user_config_dir, false, 0);
+    verify_required_directory("NETDATA_USER_CONFIG_DIR", netdata_configured_user_config_dir, false, 0);
+    verify_required_directory("NETDATA_STOCK_CONFIG_DIR", netdata_configured_stock_config_dir, false, 0);
+    verify_required_directory("NETDATA_PLUGINS_DIR", netdata_configured_primary_plugins_dir, false, 0);
+    verify_required_directory("NETDATA_WEB_DIR", netdata_configured_web_dir, false, 0);
+    verify_required_directory("NETDATA_CACHE_DIR", netdata_configured_cache_dir, true, 0775);
+    verify_required_directory("NETDATA_LIB_DIR", netdata_configured_varlib_dir, true, 0775);
+    verify_required_directory("NETDATA_LOG_DIR", netdata_configured_log_dir, true, 0775);
+    verify_required_directory("CLAIMING_DIR", netdata_configured_cloud_dir, true, 0770);
 
     {
         BUFFER *user_plugins_dirs = buffer_create(FILENAME_MAX, NULL);