check_swap: refactor to improve readability

1 files changed, 359 insertions, 0 deletions

diff --git a/plugins/check_swap.d/swap.c b/plugins/check_swap.d/swap.c
new file mode 100644
index 00000000..ebfa840d
--- /dev/null
+++ b/plugins/check_swap.d/swap.c
@@ -0,0 +1,359 @@
+#include "./check_swap.d/check_swap.h"
+
+swap_config swap_config_init() {
+        swap_config tmp = {0};
+        tmp.allswaps = false;
+        tmp.no_swap_state = STATE_CRITICAL;
+        tmp.verbose = 0;
+        tmp.conversion_factor = SWAP_CONVERSION;
+
+#ifdef _AIX
+        tmp.on_aix = true;
+#else
+        tmp.on_aix = false;
+#endif
+
+        return tmp;
+}
+
+swap_result get_swap_data(swap_config config) {
+#ifdef HAVE_PROC_MEMINFO
+        if (config.verbose >= 3) {
+                printf("Reading PROC_MEMINFO at %s\n", PROC_MEMINFO);
+        }
+
+        return getSwapFromProcMeminfo(config, PROC_MEMINFO);
+#else
+#ifdef HAVE_SWAP
+        if (config.verbose >= 3) {
+                printf("Using swap command %s with format: %s\n", SWAP_COMMAND, SWAP_FORMAT);
+        }
+
+        /* These override the command used if a summary (and thus ! allswaps) is
+         * required
+         * The summary flag returns more accurate information about swap usage on these
+         * OSes */
+        if (config.on_aix && !config.allswaps) {
+
+                config.conversion_factor = 1;
+
+                return getSwapFromSwapCommand(config, "/usr/sbin/lsps -s", "%lu%*s %lu");
+        } else {
+                return getSwapFromSwapCommand(config, SWAP_COMMAND, SWAP_FORMAT);
+        }
+#else
+#ifdef CHECK_SWAP_SWAPCTL_SVR4
+        return getSwapFromSwapctl_SRV4();
+#else
+#ifdef CHECK_SWAP_SWAPCTL_BSD
+        return getSwapFromSwapctl_BSD();
+#else
+#error No way found to retrieve swap
+#endif /* CHECK_SWAP_SWAPCTL_BSD */
+#endif /* CHECK_SWAP_SWAPCTL_SVR4 */
+#endif /* HAVE_SWAP */
+#endif /* HAVE_PROC_MEMINFO */
+}
+
+swap_result getSwapFromProcMeminfo(swap_config config, char proc_meminfo[]) {
+        FILE *fp;
+        fp = fopen(proc_meminfo, "r");
+
+        swap_result result = {0};
+        result.statusCode = STATE_OK;
+
+        uint64_t swap_total = 0, swap_used = 0, swap_free = 0;
+
+        char input_buffer[MAX_INPUT_BUFFER];
+        char str[32];
+
+        while (fgets(input_buffer, MAX_INPUT_BUFFER - 1, fp)) {
+                uint64_t tmp_KB = 0;
+
+                /*
+                 * The following sscanf call looks for a line looking like: "Swap: 123
+                 * 123 123" On which kind of system this format exists, I can not say,
+                 * but I wanted to document this for people who are not adapt with
+                 * sscanf anymore, like me
+                 * Also the units used here are unclear and probably wrong
+                 */
+                if (sscanf(input_buffer, "%*[S]%*[w]%*[a]%*[p]%*[:] %lu %lu %lu",
+                                   &swap_total, &swap_used, &swap_free) == 3) {
+
+                        result.metrics.total += swap_total;
+                        result.metrics.used += swap_used;
+                        result.metrics.free += swap_free;
+
+                        /*
+                         * The following sscanf call looks for lines looking like:
+                         * "SwapTotal: 123" and "SwapFree: 123" This format exists at least
+                         * on Debian Linux with a 5.* kernel
+                         */
+                } else if (sscanf(input_buffer,
+                                                  "%*[S]%*[w]%*[a]%*[p]%[TotalFreCchd]%*[:] %lu "
+                                                  "%*[k]%*[B]",
+                                                  str, &tmp_KB)) {
+
+                        if (config.verbose >= 3) {
+                                printf("Got %s with %lu\n", str, tmp_KB);
+                        }
+
+                        /* I think this part is always in Kb, so convert to bytes */
+                        if (strcmp("Total", str) == 0) {
+                                swap_total = tmp_KB * 1024;
+                        } else if (strcmp("Free", str) == 0) {
+                                swap_free = swap_free + tmp_KB * 1024;
+                        } else if (strcmp("Cached", str) == 0) {
+                                swap_free = swap_free + tmp_KB * 1024;
+                        }
+                }
+        }
+
+        fclose(fp);
+
+        result.metrics.total = swap_total;
+        result.metrics.used = swap_total - swap_free;
+        result.metrics.free = swap_free;
+
+        return result;
+}
+
+swap_result getSwapFromSwapCommand(swap_config config, const char swap_command[], const char swap_format[]) {
+        swap_result result = {0};
+
+        char *temp_buffer;
+
+        if (config.verbose >= 2)
+                printf(_("Command: %s\n"), swap_command);
+        if (config.verbose >= 3)
+                printf(_("Format: %s\n"), swap_format);
+
+        child_process = spopen(swap_command);
+        if (child_process == NULL) {
+                printf(_("Could not open pipe: %s\n"), swap_command);
+                swap_result tmp = {
+                        .errorcode = STATE_UNKNOWN,
+                };
+                return tmp;
+        }
+
+        child_stderr = fdopen(child_stderr_array[fileno(child_process)], "r");
+        if (child_stderr == NULL) {
+                printf(_("Could not open stderr for %s\n"), swap_command);
+        }
+
+        char str[32] = {0};
+        char input_buffer[MAX_INPUT_BUFFER];
+
+        /* read 1st line */
+        fgets(input_buffer, MAX_INPUT_BUFFER - 1, child_process);
+        if (strcmp(swap_format, "") == 0) {
+                temp_buffer = strtok(input_buffer, " \n");
+                while (temp_buffer) {
+                        if (strstr(temp_buffer, "blocks"))
+                                sprintf(str, "%s %s", str, "%lu");
+                        else if (strstr(temp_buffer, "dskfree"))
+                                sprintf(str, "%s %s", str, "%lu");
+                        else
+                                sprintf(str, "%s %s", str, "%*s");
+                        temp_buffer = strtok(NULL, " \n");
+                }
+        }
+
+        double total_swap_mb = 0, free_swap_mb = 0, used_swap_mb = 0;
+        double dsktotal_mb = 0, dskused_mb = 0, dskfree_mb = 0;
+
+        /*
+         * If different swap command is used for summary switch, need to read format
+         * differently
+         */
+        if (config.on_aix  && !config.allswaps) {
+                fgets(input_buffer, MAX_INPUT_BUFFER - 1,
+                          child_process); /* Ignore first line */
+                sscanf(input_buffer, swap_format, &total_swap_mb, &used_swap_mb);
+                free_swap_mb = total_swap_mb * (100 - used_swap_mb) / 100;
+                used_swap_mb = total_swap_mb - free_swap_mb;
+
+                if (config.verbose >= 3) {
+                        printf(_("total=%.0f, used=%.0f, free=%.0f\n"), total_swap_mb,
+                                   used_swap_mb, free_swap_mb);
+                }
+        } else {
+                while (fgets(input_buffer, MAX_INPUT_BUFFER - 1, child_process)) {
+                        sscanf(input_buffer, swap_format, &dsktotal_mb, &dskfree_mb);
+
+                        dsktotal_mb = dsktotal_mb / config.conversion_factor;
+                        /* AIX lists percent used, so this converts to dskfree in MBs */
+
+                        if (config.on_aix) {
+                                dskfree_mb = dsktotal_mb * (100 - dskfree_mb) / 100;
+                        } else {
+                                dskfree_mb = dskfree_mb / config.conversion_factor;
+                        }
+
+                        if (config.verbose >= 3)
+                                printf(_("total=%.0f, free=%.0f\n"), dsktotal_mb, dskfree_mb);
+
+                        dskused_mb = dsktotal_mb - dskfree_mb;
+                        total_swap_mb += dsktotal_mb;
+                        used_swap_mb += dskused_mb;
+                        free_swap_mb += dskfree_mb;
+                }
+        }
+
+        result.metrics.free = free_swap_mb * 1024 * 1024;
+        result.metrics.used =  used_swap_mb * 1024 * 1024;
+        result.metrics.total =  free_swap_mb  * 1024 * 1024;
+
+        /* If we get anything on STDERR, at least set warning */
+        while (fgets(input_buffer, MAX_INPUT_BUFFER - 1, child_stderr)) {
+                result.statusCode = max_state(result.statusCode, STATE_WARNING);
+                // TODO Set error here
+        }
+
+        /* close stderr */
+        (void)fclose(child_stderr);
+
+        /* close the pipe */
+        if (spclose(child_process)) {
+                result.statusCode = max_state(result.statusCode, STATE_WARNING);
+                // TODO set error here
+        }
+
+        return result;
+}
+
+#ifdef CHECK_SWAP_SWAPCTL_BSD
+swap_result getSwapFromSwapctl_BSD(swap_config config) {
+        int i = 0, nswaps = 0, swapctl_res = 0;
+        struct swapent *ent;
+
+        /* get the number of active swap devices */
+        nswaps = swapctl(SWAP_NSWAP, NULL, 0);
+
+        /* initialize swap table + entries */
+        ent = (struct swapent *)malloc(sizeof(struct swapent) * nswaps);
+
+        /* and now, tally 'em up */
+        swapctl_res = swapctl(SWAP_STATS, ent, nswaps);
+        if (swapctl_res < 0) {
+                perror(_("swapctl failed: "));
+                die(STATE_UNKNOWN, _("Error in swapctl call\n"));
+        }
+
+
+        double dsktotal_mb = 0.0, dskfree_mb = 0.0, dskused_mb = 0.0;
+        unsigned long long total_swap_mb = 0, free_swap_mb = 0, used_swap_mb = 0;
+
+        for (i = 0; i < nswaps; i++) {
+                dsktotal_mb = (float)ent[i].se_nblks / config.conversion_factor;
+                dskused_mb = (float)ent[i].se_inuse / config.conversion_factor;
+                dskfree_mb = (dsktotal_mb - dskused_mb);
+
+                if (config.allswaps && dsktotal_mb > 0) {
+                        double percent = 100 * (((double)dskused_mb) / ((double)dsktotal_mb));
+
+                        if (config.verbose) {
+                                printf("[%.0f (%g%%)]", dskfree_mb, 100 - percent);
+                        }
+                }
+
+                total_swap_mb += dsktotal_mb;
+                free_swap_mb += dskfree_mb;
+                used_swap_mb += dskused_mb;
+        }
+
+        /* and clean up after ourselves */
+        free(ent);
+
+        swap_result result = {0};
+
+        result.statusCode = OK;
+        result.errorcode = OK;
+
+        result.metrics.total =  total_swap_mb * 1024 * 1024;
+        result.metrics.free =  free_swap_mb * 1024 * 1024;
+        result.metrics.used =  used_swap_mb * 1024 * 1024;
+
+        return result;
+}
+#endif // CHECK_SWAP_SWAPCTL_BSD
+
+#ifdef CHECK_SWAP_SWAPCTL_SVR4
+swap_result getSwapFromSwap_SRV4(swap_config config) {
+        int i = 0, nswaps = 0, swapctl_res = 0;
+        //swaptbl_t *tbl = NULL;
+        void*tbl = NULL;
+        //swapent_t *ent = NULL;
+        void*ent = NULL;
+        /* get the number of active swap devices */
+        if ((nswaps = swapctl(SC_GETNSWP, NULL)) == -1)
+                die(STATE_UNKNOWN, _("Error getting swap devices\n"));
+
+        if (nswaps == 0)
+                die(STATE_OK, _("SWAP OK: No swap devices defined\n"));
+
+        if (config.verbose >= 3)
+                printf("Found %d swap device(s)\n", nswaps);
+
+        /* initialize swap table + entries */
+        tbl = (swaptbl_t *)malloc(sizeof(swaptbl_t) + (sizeof(swapent_t) * nswaps));
+
+        if (tbl == NULL)
+                die(STATE_UNKNOWN, _("malloc() failed!\n"));
+
+        memset(tbl, 0, sizeof(swaptbl_t) + (sizeof(swapent_t) * nswaps));
+        tbl->swt_n = nswaps;
+        for (i = 0; i < nswaps; i++) {
+                if ((tbl->swt_ent[i].ste_path =
+                                 (char *)malloc(sizeof(char) * MAXPATHLEN)) == NULL)
+                        die(STATE_UNKNOWN, _("malloc() failed!\n"));
+        }
+
+        /* and now, tally 'em up */
+        swapctl_res = swapctl(SC_LIST, tbl);
+        if (swapctl_res < 0) {
+                perror(_("swapctl failed: "));
+                die(STATE_UNKNOWN, _("Error in swapctl call\n"));
+        }
+
+        double dsktotal_mb = 0.0, dskfree_mb = 0.0, dskused_mb = 0.0;
+        unsigned long long total_swap_mb = 0, free_swap_mb = 0, used_swap_mb = 0;
+
+        for (i = 0; i < nswaps; i++) {
+                dsktotal_mb = (float)tbl->swt_ent[i].ste_pages / SWAP_CONVERSION;
+                dskfree_mb = (float)tbl->swt_ent[i].ste_free / SWAP_CONVERSION;
+                dskused_mb = (dsktotal_mb - dskfree_mb);
+
+                if (config.verbose >= 3)
+                        printf("dsktotal_mb=%.0f dskfree_mb=%.0f dskused_mb=%.0f\n",
+                                   dsktotal_mb, dskfree_mb, dskused_mb);
+
+                if (config.allswaps && dsktotal_mb > 0) {
+                        double percent = 100 * (((double)dskused_mb) / ((double)dsktotal_mb));
+
+                        if (config.verbose) {
+                                printf("[%.0f (%g%%)]", dskfree_mb, 100 - percent);
+                        }
+                }
+
+                total_swap_mb += dsktotal_mb;
+                free_swap_mb += dskfree_mb;
+                used_swap_mb += dskused_mb;
+        }
+
+        /* and clean up after ourselves */
+        for (i = 0; i < nswaps; i++) {
+                free(tbl->swt_ent[i].ste_path);
+        }
+        free(tbl);
+
+        swap_result result = {0};
+        result.errorcode = OK;
+        result.metrics.total = total_swap_mb * 1024 * 1024;
+        result.metrics.free = free_swap_mb * 1024 * 1024;
+        result.metrics.used = used_swap_mb * 1024 * 1024;
+
+        return result;
+}
+#endif // CHECK_SWAP_SWAPCTL_SVR4