From 2dec5182c508bd3cc286b4649836ead51aec50ef Mon Sep 17 00:00:00 2001 From: RincewindsHat <12514511+RincewindsHat@users.noreply.github.com> Date: Tue, 19 Dec 2023 11:18:51 +0100 Subject: check_swap: refactor to improve readability --- plugins/check_swap.d/swap.c | 359 ++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 359 insertions(+) create mode 100644 plugins/check_swap.d/swap.c (limited to 'plugins/check_swap.d/swap.c') 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 -- cgit v1.2.3-74-g34f1