From 3a10773c0918a190c43d1508f9f572709fba25a8 Mon Sep 17 00:00:00 2001 From: RincewindsHat <12514511+RincewindsHat@users.noreply.github.com> Date: Wed, 13 Dec 2023 16:17:47 +0100 Subject: check_swap: Heavily refactored linux part --- plugins/check_swap.c | 776 +++++++++++++++++++++++++++------------------------ 1 file changed, 404 insertions(+), 372 deletions(-) (limited to 'plugins/check_swap.c') diff --git a/plugins/check_swap.c b/plugins/check_swap.c index 9630071a..60309a76 100644 --- a/plugins/check_swap.c +++ b/plugins/check_swap.c @@ -56,70 +56,335 @@ typedef struct { uint64_t value; } threshold; -int check_swap (float free_swap_mb, float total_swap_mb); -int process_arguments (int argc, char **argv); -int validate_arguments (void); -void print_usage (void); -void print_help (void); - -threshold warn; -threshold crit; -int verbose; -bool allswaps = false; -int no_swap_state = STATE_CRITICAL; - -int -main (int argc, char **argv) -{ - unsigned int percent_used, percent; - uint64_t total_swap_mb = 0, used_swap_mb = 0, free_swap_mb = 0; - uint64_t dsktotal_mb = 0, dskused_mb = 0, dskfree_mb = 0; - uint64_t tmp_KB = 0; - int result = STATE_UNKNOWN; - char input_buffer[MAX_INPUT_BUFFER]; -#ifdef HAVE_PROC_MEMINFO - FILE *fp; -#else - int conv_factor = SWAP_CONVERSION; -# ifdef HAVE_SWAP - char *temp_buffer; - char *swap_command; - char *swap_format; -# else -# ifdef HAVE_DECL_SWAPCTL - int i=0, nswaps=0, swapctl_res=0; -# ifdef CHECK_SWAP_SWAPCTL_SVR4 - swaptbl_t *tbl=NULL; - swapent_t *ent=NULL; -# else -# ifdef CHECK_SWAP_SWAPCTL_BSD - struct swapent *ent; -# endif /* CHECK_SWAP_SWAPCTL_BSD */ -# endif /* CHECK_SWAP_SWAPCTL_SVR4 */ -# endif /* HAVE_DECL_SWAPCTL */ -# endif -#endif - char str[32]; - char *status; +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; +} swap_config; + +typedef struct { + int errorcode; + swap_config config; +} swap_config_wrapper; + +swap_config_wrapper process_arguments (swap_config_wrapper config, int argc, char **argv); +void print_usage (); +void print_help (swap_config); + +swap_result getSwapFromProcMeminfo(swap_config config); +swap_result getSwapFromSwapCommand(swap_config config); +swap_result getSwapFromSwapctl_BSD(swap_config config); +swap_result getSwapFromSwap_SRV4(swap_config config); + +swap_config swap_config_init() { + swap_config tmp = { 0 }; + tmp.allswaps = false; + tmp.no_swap_state = STATE_CRITICAL; + tmp.verbose = 0; + + return tmp; +} + +int main (int argc, char **argv) { setlocale (LC_ALL, ""); bindtextdomain (PACKAGE, LOCALEDIR); textdomain (PACKAGE); + char *status; status = strdup (""); /* Parse extra opts if any */ argv=np_extra_opts (&argc, argv, progname); - if (process_arguments (argc, argv) == ERROR) + swap_config_wrapper tmp = { + .errorcode = OK + }; + + tmp.config = swap_config_init(); + + tmp = process_arguments (tmp, argc, argv); + + if (tmp.errorcode != OK) { usage4 (_("Could not parse arguments")); + } + + swap_config config = tmp.config; + +#ifdef HAVE_PROC_MEMINFO + swap_result data = getSwapFromProcMeminfo(config); +#else +# ifdef HAVE_SWAP + swap_result data = getSwapFromSwapCommand(); +# else +# ifdef CHECK_SWAP_SWAPCTL_SVR4 + swap_result data = getSwapFromSwapctl_SRV4(); +# else +# ifdef CHECK_SWAP_SWAPCTL_BSD + swap_result data = getSwapFromSwapctl_BSD(); +# else + #error No now found to retrieve swap +# endif /* CHECK_SWAP_SWAPCTL_BSD */ +# endif /* CHECK_SWAP_SWAPCTL_SVR4 */ +# endif /* HAVE_SWAP */ +#endif /* HAVE_PROC_MEMINFO */ + + double percent_used; + + /* if total_swap_mb == 0, let's not divide by 0 */ + if(data.metrics.total != 0) { + percent_used = 100 * ((double) data.metrics.used) / ((double) data.metrics.total); + } else { + printf (_("SWAP %s - Swap is either disabled, not present, or of zero size."), + state_text (data.statusCode)); + exit(config.no_swap_state); + } + + uint64_t warn_print = config.warn.value; + if (config.warn.is_percentage) { + warn_print = config.warn.value * (data.metrics.total*1024 *1024/100); + } + + uint64_t crit_print = config.crit.value; + if (config.crit.is_percentage) { + crit_print = config.crit.value * (data.metrics.total*1024 *1024/100); + } + + char *perfdata = perfdata_uint64 ("swap", data.metrics.free *1024 *1024, "B", + true, warn_print, + true, crit_print, + true, 0, + true, (long) data.metrics.total* 1024 * 1024); + + if ((config.warn.is_percentage && (percent_used >= (100 - config.warn.value))) || + config.warn.value >= data.metrics.free) { + data.statusCode = max_state (data.statusCode, STATE_WARNING); + } + + if ((config.crit.is_percentage && (percent_used >= (100 - config.crit.value))) || + config.crit.value >= data.metrics.free) { + data.statusCode = max_state (data.statusCode, STATE_CRITICAL); + } + + printf (_("SWAP %s - %g%% free (%lluMB out of %lluMB) %s|%s\n"), + state_text (data.statusCode), + (100 - percent_used), data.metrics.free, data.metrics.total, status, + perfdata); + + exit(data.statusCode); +} + + +/* process command-line arguments */ +swap_config_wrapper process_arguments (swap_config_wrapper conf_wrapper, int argc, char **argv) { + if (argc < 2) { + conf_wrapper.errorcode = ERROR; + return conf_wrapper; + } + + int option = 0; + static struct option longopts[] = { + {"warning", required_argument, 0, 'w'}, + {"critical", required_argument, 0, 'c'}, + {"allswaps", no_argument, 0, 'a'}, + {"no-swap", required_argument, 0, 'n'}, + {"verbose", no_argument, 0, 'v'}, + {"version", no_argument, 0, 'V'}, + {"help", no_argument, 0, 'h'}, + {0, 0, 0, 0} + }; + + int c = 0; /* option character */ + while (true) { + c = getopt_long (argc, argv, "+?Vvhac:w:n:", longopts, &option); + + if (c == -1 || c == EOF) + break; + + switch (c) { + case 'w': /* warning size threshold */ + { + /* + * We expect either a positive integer value without a unit, which means + * the unit is Bytes or a positive integer value and a percentage sign (%), + * which means the value must be with 0 and 100 and is relative to the total swap + */ + size_t length; + length = strlen(optarg); + + if (optarg[length - 1] == '%') { + /* It's percentage */ + conf_wrapper.config.warn.is_percentage = true; + optarg[length - 1] = '\0'; + if (is_uint64(optarg, &conf_wrapper.config.warn.value)) { + if (conf_wrapper.config.warn.value > 100) { + usage4 (_("Warning threshold percentage must be <= 100!")); + } + } + break; + } else { + /* It's Bytes */ + conf_wrapper.config.warn.is_percentage = false; + if (is_uint64(optarg, &conf_wrapper.config.warn.value)) { + break; + } else { + usage4 (_("Warning threshold be positive integer or percentage!")); + } + } + } + case 'c': /* critical size threshold */ + { + /* + * We expect either a positive integer value without a unit, which means + * the unit is Bytes or a positive integer value and a percentage sign (%), + * which means the value must be with 0 and 100 and is relative to the total swap + */ + size_t length; + length = strlen(optarg); + + if (optarg[length - 1] == '%') { + /* It's percentage */ + conf_wrapper.config.crit.is_percentage = true; + optarg[length - 1] = '\0'; + if (is_uint64(optarg, &conf_wrapper.config.crit.value)) { + if (conf_wrapper.config.crit.value> 100) { + usage4 (_("Critical threshold percentage must be <= 100!")); + } + } + break; + } else { + /* It's Bytes */ + conf_wrapper.config.crit.is_percentage = false; + if (is_uint64(optarg, &conf_wrapper.config.crit.value)) { + break; + } else { + usage4 (_("Critical threshold be positive integer or percentage!")); + } + } + } + case 'a': /* all swap */ + conf_wrapper.config.allswaps = true; + break; + case 'n': + if ((conf_wrapper.config.no_swap_state = mp_translate_state(optarg)) == ERROR) { + usage4 (_("no-swap result must be a valid state name (OK, WARNING, CRITICAL, UNKNOWN) or integer (0-3).")); + } + break; + case 'v': /* verbose */ + conf_wrapper.config.verbose++; + break; + case 'V': /* version */ + print_revision (progname, NP_VERSION); + exit (STATE_UNKNOWN); + case 'h': /* help */ + print_help (conf_wrapper.config); + exit (STATE_UNKNOWN); + case '?': /* error */ + usage5 (); + } + } + + c = optind; + + if (conf_wrapper.config.warn.value == 0 && conf_wrapper.config.crit.value == 0) { + conf_wrapper.errorcode = ERROR; + return conf_wrapper; + } else if ((conf_wrapper.config.warn.is_percentage == conf_wrapper.config.crit.is_percentage) && + (conf_wrapper.config.warn.value < conf_wrapper.config.crit.value)) { + /* This is NOT triggered if warn and crit are different units, e.g warn is percentage + * and crit is absolute. We cannot determine the condition at this point since we + * dont know the value of total swap yet + */ + usage4(_("Warning should be more than critical")); + } + + return conf_wrapper; +} + + +void +print_help (swap_config config) +{ + print_revision (progname, NP_VERSION); + + printf (_(COPYRIGHT), copyright, email); + + printf ("%s\n", _("Check swap space on local machine.")); + + printf ("\n\n"); + + print_usage(); + + printf (UT_HELP_VRSN); + printf (UT_EXTRA_OPTS); + + printf (" %s\n", "-w, --warning=INTEGER"); + printf (" %s\n", _("Exit with WARNING status if less than INTEGER bytes of swap space are free")); + printf (" %s\n", "-w, --warning=PERCENT%"); + printf (" %s\n", _("Exit with WARNING status if less than PERCENT of swap space is free")); + printf (" %s\n", "-c, --critical=INTEGER"); + printf (" %s\n", _("Exit with CRITICAL status if less than INTEGER bytes of swap space are free")); + printf (" %s\n", "-c, --critical=PERCENT%"); + printf (" %s\n", _("Exit with CRITICAL status if less than PERCENT of swap space is free")); + printf (" %s\n", "-a, --allswaps"); + printf (" %s\n", _("Conduct comparisons for all swap partitions, one by one")); + printf (" %s\n", "-n, --no-swap="); + printf (" %s %s\n", _("Resulting state when there is no swap regardless of thresholds. Default:"), state_text(config.no_swap_state)); + printf (UT_VERBOSE); + + printf ("\n"); + printf ("%s\n", _("Notes:")); + printf (" %s\n", _("Both INTEGER and PERCENT thresholds can be specified, they are all checked.")); + printf (" %s\n", _("On AIX, if -a is specified, uses lsps -a, otherwise uses lsps -s.")); + + printf (UT_SUPPORT); +} + + +void +print_usage () +{ + printf ("%s\n", _("Usage:")); + printf (" %s [-av] -w %% -c %%\n",progname); + printf (" -w -c [-n ]\n"); +} #ifdef HAVE_PROC_MEMINFO - if (verbose >= 3) { +swap_result getSwapFromProcMeminfo(swap_config config) { + + if (config.verbose >= 3) { printf("Reading PROC_MEMINFO at %s\n", PROC_MEMINFO); } + + FILE *fp; fp = fopen (PROC_MEMINFO, "r"); + + + swap_result result = { 0 }; + result.statusCode = STATE_OK; + + uint64_t dsktotal_mb = 0, dskused_mb = 0, dskfree_mb = 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 @@ -129,59 +394,63 @@ main (int argc, char **argv) dsktotal_mb = dsktotal_mb / (1024 * 1024); /* Apply conversion */ dskused_mb = dskused_mb / (1024 * 1024); dskfree_mb = dskfree_mb / (1024 * 1024); - total_swap_mb += dsktotal_mb; - used_swap_mb += dskused_mb; - free_swap_mb += dskfree_mb; - if (allswaps) { - if (dsktotal_mb == 0) - percent=100.0; - else - percent = 100 * (((double) dskused_mb) / ((double) dsktotal_mb)); - result = max_state (result, check_swap (dskfree_mb, dsktotal_mb)); - if (verbose) - xasprintf (&status, "%s [%lu (%d%%)]", status, dskfree_mb, 100 - percent); - } - } + + result.metrics.total += dsktotal_mb; + result.metrics.used+= dskused_mb; + result.metrics.free += dskfree_mb; + + /* * 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 (verbose >= 3) { + } 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 mb */ if (strcmp ("Total", str) == 0) { dsktotal_mb = tmp_KB / 1024; - } - else if (strcmp ("Free", str) == 0) { + } else if (strcmp ("Free", str) == 0) { dskfree_mb = dskfree_mb + tmp_KB / 1024; - } - else if (strcmp ("Cached", str) == 0) { + } else if (strcmp ("Cached", str) == 0) { dskfree_mb = dskfree_mb + tmp_KB / 1024; } } } + fclose(fp); - dskused_mb = dsktotal_mb - dskfree_mb; - total_swap_mb = dsktotal_mb; - used_swap_mb = dskused_mb; - free_swap_mb = dskfree_mb; -#else -# ifdef HAVE_SWAP + + result.metrics.total = dsktotal_mb; + result.metrics.used = dsktotal_mb - dskfree_mb; + result.metrics.free = dskfree_mb; + + return result; +} +#endif + +#ifdef HAVE_SWAP +swap_result getSwapFromSwapCommand() { + swap_result result = { 0 }; + + char *temp_buffer; + char *swap_command; + char *swap_format; + int conv_factor = SWAP_CONVERSION; + xasprintf(&swap_command, "%s", SWAP_COMMAND); xasprintf(&swap_format, "%s", 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 */ -# ifdef _AIX +# ifdef _AIX if (!allswaps) { xasprintf(&swap_command, "%s", "/usr/sbin/lsps -s"); xasprintf(&swap_format, "%s", "%lu%*s %lu"); conv_factor = 1; } -# endif +# endif if (verbose >= 2) printf (_("Command: %s\n"), swap_command); @@ -215,7 +484,7 @@ main (int argc, char **argv) } /* If different swap command is used for summary switch, need to read format differently */ -# ifdef _AIX +# ifdef _AIX if (!allswaps) { fgets(input_buffer, MAX_INPUT_BUFFER - 1, child_process); /* Ignore first line */ sscanf (input_buffer, swap_format, &total_swap_mb, &used_swap_mb); @@ -224,7 +493,7 @@ main (int argc, char **argv) if (verbose >= 3) printf (_("total=%.0f, used=%.0f, free=%.0f\n"), total_swap_mb, used_swap_mb, free_swap_mb); } else { -# endif +# endif while (fgets (input_buffer, MAX_INPUT_BUFFER - 1, child_process)) { sscanf (input_buffer, swap_format, &dsktotal_mb, &dskfree_mb); @@ -251,21 +520,68 @@ main (int argc, char **argv) } # ifdef _AIX } -# endif +# endif + + /* If we get anything on STDERR, at least set warning */ + while (fgets (input_buffer, MAX_INPUT_BUFFER - 1, child_stderr)) + result = max_state (result, STATE_WARNING); + + /* close stderr */ + (void) fclose (child_stderr); + + /* close the pipe */ + if (spclose (child_process)) + result = max_state (result, STATE_WARNING); +} +#endif // HAVE_SWAP + +#ifdef CHECK_SWAP_SWAPCTL_BSD +swap_result getSwapFromSwapctl_BSD() { + int i=0, nswaps=0, swapctl_res=0; + struct swapent *ent; + int conv_factor = SWAP_CONVERSION; + + /* 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")); + } - /* If we get anything on STDERR, at least set warning */ - while (fgets (input_buffer, MAX_INPUT_BUFFER - 1, child_stderr)) - result = max_state (result, STATE_WARNING); + for(i=0;i 0){ + percent = 100 * (((double) dskused_mb) / ((double) dsktotal_mb)); + result = max_state (result, check_swap(dskfree_mb, dsktotal_mb)); + if (verbose) { + xasprintf (&status, "%s [%.0f (%d%%)]", status, dskfree_mb, 100 - percent); + } + } - /* close the pipe */ - if (spclose (child_process)) - result = max_state (result, STATE_WARNING); -# else -# ifdef CHECK_SWAP_SWAPCTL_SVR4 + total_swap_mb += dsktotal_mb; + free_swap_mb += dskfree_mb; + used_swap_mb += dskused_mb; + } + + /* and clean up after ourselves */ + free(ent); +} +#endif // CHECK_SWAP_SWAPCTL_BSD +#ifdef CHECK_SWAP_SWAPCTL_SVR4 +swap_result getSwapFromSwap_SRV4() { + int i=0, nswaps=0, swapctl_res=0; + swaptbl_t *tbl=NULL; + swapent_t *ent=NULL; /* get the number of active swap devices */ if((nswaps=swapctl(SC_GETNSWP, NULL))== -1) die(STATE_UNKNOWN, _("Error getting swap devices\n") ); @@ -322,289 +638,5 @@ main (int argc, char **argv) free(tbl->swt_ent[i].ste_path); } free(tbl); -# else -# ifdef CHECK_SWAP_SWAPCTL_BSD - - /* 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")); - } - - for(i=0;i 0){ - percent = 100 * (((double) dskused_mb) / ((double) dsktotal_mb)); - result = max_state (result, check_swap(dskfree_mb, dsktotal_mb)); - if (verbose) { - xasprintf (&status, "%s [%.0f (%d%%)]", status, 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); - -# endif /* CHECK_SWAP_SWAPCTL_BSD */ -# endif /* CHECK_SWAP_SWAPCTL_SVR4 */ -# endif /* HAVE_SWAP */ -#endif /* HAVE_PROC_MEMINFO */ - - /* if total_swap_mb == 0, let's not divide by 0 */ - if(total_swap_mb) { - percent_used = 100 * ((double) used_swap_mb) / ((double) total_swap_mb); - } else { - percent_used = 100; - status = "- Swap is either disabled, not present, or of zero size. "; - } - - result = max_state (result, check_swap(free_swap_mb, total_swap_mb)); - printf (_("SWAP %s - %d%% free (%dMB out of %dMB) %s|"), - state_text (result), - (100 - percent_used), (int) free_swap_mb, (int) total_swap_mb, status); - - uint64_t warn_print = warn.value; - if (warn.is_percentage) warn_print = warn.value * (total_swap_mb *1024 *1024/100); - uint64_t crit_print = crit.value; - if (crit.is_percentage) crit_print = crit.value * (total_swap_mb *1024 *1024/100); - - puts (perfdata_uint64 ("swap", free_swap_mb *1024 *1024, "B", - true, warn_print, - true, crit_print, - true, 0, - true, (long) total_swap_mb * 1024 * 1024)); - - return result; -} - - -int -check_swap(float free_swap_mb, float total_swap_mb) -{ - - if (!total_swap_mb) return no_swap_state; - - uint64_t free_swap = free_swap_mb * (1024 * 1024); /* Convert back to bytes as warn and crit specified in bytes */ - - if (!crit.is_percentage && crit.value >= free_swap) return STATE_CRITICAL; - if (!warn.is_percentage && warn.value >= free_swap) return STATE_WARNING; - - - uint64_t usage_percentage = ((total_swap_mb - free_swap_mb) / total_swap_mb) * 100; - - if (crit.is_percentage && - crit.value != 0 && - usage_percentage >= (100 - crit.value)) - { - return STATE_CRITICAL; - } - - if (warn.is_percentage && - warn.value != 0 && - usage_percentage >= (100 - warn.value)) - { - return STATE_WARNING; - } - - return STATE_OK; -} - - - -/* process command-line arguments */ -int -process_arguments (int argc, char **argv) -{ - int c = 0; /* option character */ - - int option = 0; - static struct option longopts[] = { - {"warning", required_argument, 0, 'w'}, - {"critical", required_argument, 0, 'c'}, - {"allswaps", no_argument, 0, 'a'}, - {"no-swap", required_argument, 0, 'n'}, - {"verbose", no_argument, 0, 'v'}, - {"version", no_argument, 0, 'V'}, - {"help", no_argument, 0, 'h'}, - {0, 0, 0, 0} - }; - - if (argc < 2) - return ERROR; - - while (1) { - c = getopt_long (argc, argv, "+?Vvhac:w:n:", longopts, &option); - - if (c == -1 || c == EOF) - break; - - switch (c) { - case 'w': /* warning size threshold */ - { - /* - * We expect either a positive integer value without a unit, which means - * the unit is Bytes or a positive integer value and a percentage sign (%), - * which means the value must be with 0 and 100 and is relative to the total swap - */ - size_t length; - length = strlen(optarg); - - if (optarg[length - 1] == '%') { - /* It's percentage */ - warn.is_percentage = true; - optarg[length - 1] = '\0'; - if (is_uint64(optarg, &warn.value)) { - if (warn.value > 100) { - usage4 (_("Warning threshold percentage must be <= 100!")); - } - } - break; - } else { - /* It's Bytes */ - warn.is_percentage = false; - if (is_uint64(optarg, &warn.value)) { - break; - } else { - usage4 (_("Warning threshold be positive integer or percentage!")); - } - } - } - case 'c': /* critical size threshold */ - { - /* - * We expect either a positive integer value without a unit, which means - * the unit is Bytes or a positive integer value and a percentage sign (%), - * which means the value must be with 0 and 100 and is relative to the total swap - */ - size_t length; - length = strlen(optarg); - - if (optarg[length - 1] == '%') { - /* It's percentage */ - crit.is_percentage = true; - optarg[length - 1] = '\0'; - if (is_uint64(optarg, &crit.value)) { - if (crit.value> 100) { - usage4 (_("Critical threshold percentage must be <= 100!")); - } - } - break; - } else { - /* It's Bytes */ - crit.is_percentage = false; - if (is_uint64(optarg, &crit.value)) { - break; - } else { - usage4 (_("Critical threshold be positive integer or percentage!")); - } - } - } - case 'a': /* all swap */ - allswaps = true; - break; - case 'n': - if ((no_swap_state = mp_translate_state(optarg)) == ERROR) { - usage4 (_("no-swap result must be a valid state name (OK, WARNING, CRITICAL, UNKNOWN) or integer (0-3).")); - } - break; - case 'v': /* verbose */ - verbose++; - break; - case 'V': /* version */ - print_revision (progname, NP_VERSION); - exit (STATE_UNKNOWN); - case 'h': /* help */ - print_help (); - exit (STATE_UNKNOWN); - case '?': /* error */ - usage5 (); - } - } - - c = optind; - if (c == argc) - return validate_arguments (); - - return validate_arguments (); -} - - - -int -validate_arguments (void) -{ - if (warn.value == 0 && crit.value == 0) { - return ERROR; - } - else if ((warn.is_percentage == crit.is_percentage) && (warn.value < crit.value)) { - /* This is NOT triggered if warn and crit are different units, e.g warn is percentage - * and crit is absolute. We cannot determine the condition at this point since we - * dont know the value of total swap yet - */ - usage4(_("Warning should be more than critical")); - } - return OK; -} - - - -void -print_help (void) -{ - print_revision (progname, NP_VERSION); - - printf (_(COPYRIGHT), copyright, email); - - printf ("%s\n", _("Check swap space on local machine.")); - - printf ("\n\n"); - - print_usage (); - - printf (UT_HELP_VRSN); - printf (UT_EXTRA_OPTS); - - printf (" %s\n", "-w, --warning=INTEGER"); - printf (" %s\n", _("Exit with WARNING status if less than INTEGER bytes of swap space are free")); - printf (" %s\n", "-w, --warning=PERCENT%"); - printf (" %s\n", _("Exit with WARNING status if less than PERCENT of swap space is free")); - printf (" %s\n", "-c, --critical=INTEGER"); - printf (" %s\n", _("Exit with CRITICAL status if less than INTEGER bytes of swap space are free")); - printf (" %s\n", "-c, --critical=PERCENT%"); - printf (" %s\n", _("Exit with CRITICAL status if less than PERCENT of swap space is free")); - printf (" %s\n", "-a, --allswaps"); - printf (" %s\n", _("Conduct comparisons for all swap partitions, one by one")); - printf (" %s\n", "-n, --no-swap="); - printf (" %s %s\n", _("Resulting state when there is no swap regardless of thresholds. Default:"), state_text(no_swap_state)); - printf (UT_VERBOSE); - - printf ("\n"); - printf ("%s\n", _("Notes:")); - printf (" %s\n", _("Both INTEGER and PERCENT thresholds can be specified, they are all checked.")); - printf (" %s\n", _("On AIX, if -a is specified, uses lsps -a, otherwise uses lsps -s.")); - - printf (UT_SUPPORT); -} - - -void -print_usage (void) -{ - printf ("%s\n", _("Usage:")); - printf (" %s [-av] -w %% -c %%\n",progname); - printf (" -w -c [-n ]\n"); } +#endif // CHECK_SWAP_SWAPCTL_SVR4 -- cgit v1.2.3-74-g34f1