2 files changed, 460 insertions, 0 deletions

diff --git a/plugins/check_swap.d/check_swap.h b/plugins/check_swap.d/check_swap.h
new file mode 100644
index 00000000..bad52917
--- /dev/null
+++ b/plugins/check_swap.d/check_swap.h
@@ -0,0 +1,45 @@
+#ifndef CHECK_SWAP_H
+#define CHECK_SWAP_H
+
+#include "../common.h"
+
+#ifndef SWAP_CONVERSION
+#define SWAP_CONVERSION 1
+#endif
+
+typedef struct {
+        bool is_percentage;
+        uint64_t value;
+} threshold;
+
+typedef struct {
+        unsigned long long free;  // Free swap in Bytes!
+        unsigned long long used;  // Used swap in Bytes!
+        unsigned long long total; // Total swap size, you guessed it, in Bytes!
+} swap_metrics;
+
+typedef struct {
+        int errorcode;
+        int statusCode;
+        swap_metrics metrics;
+} swap_result;
+
+typedef struct {
+        int verbose;
+        bool allswaps;
+        int no_swap_state;
+        threshold warn;
+        threshold crit;
+        bool on_aix;
+        int conversion_factor;
+} swap_config;
+
+swap_config swap_config_init();
+
+swap_result get_swap_data(swap_config config);
+swap_result getSwapFromProcMeminfo(swap_config config, char path_to_proc_meminfo[]);
+swap_result getSwapFromSwapCommand(swap_config config, const char swap_command[], const char swap_format[]);
+swap_result getSwapFromSwapctl_BSD(swap_config config);
+swap_result getSwapFromSwap_SRV4(swap_config config);
+
+#endif
diff --git a/plugins/check_swap.d/swap.c b/plugins/check_swap.d/swap.c
new file mode 100644
index 00000000..50920fa3
--- /dev/null
+++ b/plugins/check_swap.d/swap.c
@@ -0,0 +1,415 @@
+#include "./check_swap.d/check_swap.h"
+#include "../popen.h"
+#include "../utils.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;
+}
+
+#ifndef CHECK_SWAP_SWAPCTL_BSD
+#define CHECK_SWAP_SWAPCTL_BSD
+
+// Stub functionality for BSD stuff, so the compiler always sees the following BSD code
+
+#define SWAP_NSWAP 0
+#define SWAP_STATS 1
+
+int bsd_swapctl(int cmd, const void *arg, int misc) {
+        (void) cmd;
+        (void) arg;
+        (void) misc;
+        return 512;
+}
+
+struct swapent {
+        dev_t   se_dev;                 /* device id */
+        int     se_flags;               /* entry flags */
+        int     se_nblks;               /* total blocks */
+        int     se_inuse;               /* blocks in use */
+        int     se_priority;            /* priority */
+        char    se_path[PATH_MAX];      /* path to entry */
+};
+
+#else
+#define bsd_swapctl swapctl
+#endif
+
+swap_result getSwapFromSwapctl_BSD(swap_config config) {
+        /* get the number of active swap devices */
+        int nswaps = bsd_swapctl(SWAP_NSWAP, NULL, 0);
+
+        /* initialize swap table + entries */
+        struct swapent *ent = (struct swapent *)malloc(sizeof(struct swapent) * nswaps);
+
+        /* and now, tally 'em up */
+        int swapctl_res = bsd_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 (int 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;
+}
+
+
+
+#ifndef CHECK_SWAP_SWAPCTL_SVR4
+int srv4_swapctl(int cmd, void *arg) {
+        (void) cmd;
+        (void) arg;
+        return 512;
+}
+
+typedef struct srv4_swapent {
+        char   *ste_path;    /* name of the swap        file */
+        off_t  ste_start;    /* starting        block for swapping */
+        off_t  ste_length;   /* length of swap area */
+        long   ste_pages;    /* number of pages for swapping */
+        long   ste_free;            /* number of ste_pages free */
+        long   ste_flags;    /* ST_INDEL        bit set if swap file */
+        /* is now being deleted */
+} swapent_t;
+
+typedef struct swaptbl {
+        int            swt_n;       /* number of swapents following */
+        struct srv4_swapent swt_ent[];   /* array       of swt_n swapents */
+} swaptbl_t;
+
+#define SC_LIST 2
+#define SC_GETNSWP 3
+
+#ifndef MAXPATHLEN
+#define MAXPATHLEN 2048
+#endif
+
+#else
+#define srv4_swapctl swapctl
+#endif
+
+swap_result getSwapFromSwap_SRV4(swap_config config) {
+        int nswaps = 0;
+
+        /* get the number of active swap devices */
+        if ((nswaps = srv4_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 */
+        swaptbl_t *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 (int 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 */
+        int swapctl_res = srv4_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 (int 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 (int 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;
+}