X-Git-Url: https://git.tokkee.org/?a=blobdiff_plain;f=plugins%2Fcheck_swap.c;h=aeeb9ba0a8872044e55dc1064a91f00c38cbac0e;hb=9d878eab82bede19e80b4aa9ce1409da3ba6d658;hp=da18ccb87d9b8f5c1deb0e310929a708e54177e0;hpb=c4e83a42c9b2fa09b1548a3c76e1a0f1d22bc30a;p=nagiosplug.git diff --git a/plugins/check_swap.c b/plugins/check_swap.c index da18ccb..aeeb9ba 100644 --- a/plugins/check_swap.c +++ b/plugins/check_swap.c @@ -1,88 +1,167 @@ /****************************************************************************** -* -* CHECK_SWAP.C -* -* Program: Process plugin for Nagios -* License: GPL -* Copyright (c) 2000 Karl DeBisschop (kdebisschop@users.sourceforge.net) -* -* $Id$ -* -******************************************************************************/ + * + * Program: Swap space plugin for Nagios + * License: GPL + * + * License Information: + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + * + * Copyright (c) 2000 Karl DeBisschop (kdebisschop@users.sourceforge.net) + * + * $Id$ + * + *****************************************************************************/ + +const char *progname = "check_swap"; +const char *revision = "$Revision$"; +const char *copyright = "2000-2004"; +const char *email = "nagiosplug-devel@lists.sourceforge.net"; #include "common.h" #include "popen.h" #include "utils.h" -#define PROGNAME "check_swap" - +int check_swap (int usp, float free_swap); int process_arguments (int argc, char **argv); int validate_arguments (void); void print_usage (void); void print_help (void); -int warn_percent = 200, crit_percent = 200, warn_size = -1, crit_size = -1; +int warn_percent = 0; +int crit_percent = 0; +double warn_size = 0; +double crit_size = 0; +int verbose; +int allswaps; int main (int argc, char **argv) { - int total_swap = 0, used_swap = 0, free_swap = 0, percent_used; - int total, used, free; - int result = STATE_OK; + int percent_used, percent; + float total_swap = 0, used_swap = 0, free_swap = 0; + float dsktotal = 0, dskused = 0, dskfree = 0, tmp = 0; + int result = STATE_UNKNOWN; char input_buffer[MAX_INPUT_BUFFER]; -#ifdef HAVE_SWAP - char *temp_buffer; -#endif #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 = ""; + char *status; - if (process_arguments (argc, argv) != OK) - usage ("Invalid command arguments supplied\n"); + setlocale (LC_ALL, ""); + bindtextdomain (PACKAGE, LOCALEDIR); + textdomain (PACKAGE); + + status = strdup (""); + + if (process_arguments (argc, argv) == ERROR) + usage4 (_("Could not parse arguments")); #ifdef HAVE_PROC_MEMINFO fp = fopen (PROC_MEMINFO, "r"); - asprintf (&status, "%s", "Swap used:"); while (fgets (input_buffer, MAX_INPUT_BUFFER - 1, fp)) { - if (sscanf (input_buffer, " %s %d %d %d", str, &total, &used, &free) == 4 && - strstr (str, "Swap")) { -/* asprintf (&status, "%s [%d/%d]", status, used, total); */ - total_swap += total; - used_swap += used; - free_swap += free; + if (sscanf (input_buffer, "%*[S]%*[w]%*[a]%*[p]%*[:] %f %f %f", &dsktotal, &dskused, &dskfree) == 3) { + dsktotal = dsktotal / 1048576; + dskused = dskused / 1048576; + dskfree = dskfree / 1048576; + total_swap += dsktotal; + used_swap += dskused; + free_swap += dskfree; + if (allswaps) { + if (dsktotal == 0) + percent=100.0; + else + percent = 100 * (((double) dskused) / ((double) dsktotal)); + result = max_state (result, check_swap (percent, dskfree)); + if (verbose) + asprintf (&status, "%s [%.0f (%d%%)]", status, dskfree, 100 - percent); + } + } + else if (sscanf (input_buffer, "%*[S]%*[w]%*[a]%*[p]%[TotalFre]%*[:] %f %*[k]%*[B]", str, &tmp)) { + if (strcmp ("Total", str) == 0) { + dsktotal = tmp / 1024; + } + else if (strcmp ("Free", str) == 0) { + dskfree = tmp / 1024; + } } } - percent_used = 100 * (((float) used_swap) / ((float) total_swap)); - if (percent_used >= crit_percent || free_swap <= crit_size) - result = STATE_CRITICAL; - else if (percent_used >= warn_percent || free_swap <= warn_size) - result = STATE_WARNING; - asprintf (&status, "%s %2d%% (%d out of %d)", status, percent_used, - used_swap, total_swap); - fclose (fp); + fclose(fp); + dskused = dsktotal - dskfree; + total_swap = dsktotal; + used_swap = dskused; + free_swap = dskfree; #else -#ifdef HAVE_SWAP - child_process = spopen (SWAP_COMMAND); +# ifdef HAVE_SWAP + asprintf(&swap_command, "%s", SWAP_COMMAND); + asprintf(&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 + if (!allswaps) { + asprintf(&swap_command, "%s", "/usr/sbin/lsps -s"); + asprintf(&swap_format, "%s", "%f%*s %f"); + conv_factor = 1; + } +# endif + + if (verbose >= 2) + printf (_("Command: %s\n"), swap_command); + if (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); + printf (_("Could not open pipe: %s\n"), swap_command); return STATE_UNKNOWN; } child_stderr = fdopen (child_stderr_array[fileno (child_process)], "r"); if (child_stderr == NULL) - printf ("Could not open stderr for %s\n", SWAP_COMMAND); + printf (_("Could not open stderr for %s\n"), swap_command); sprintf (str, "%s", ""); /* read 1st line */ fgets (input_buffer, MAX_INPUT_BUFFER - 1, child_process); - if (strcmp (SWAP_FORMAT, "") == 0) { + if (strcmp (swap_format, "") == 0) { temp_buffer = strtok (input_buffer, " \n"); while (temp_buffer) { if (strstr (temp_buffer, "blocks")) sprintf (str, "%s %s", str, "%f"); - else if (strstr (temp_buffer, "free")) + else if (strstr (temp_buffer, "dskfree")) sprintf (str, "%s %s", str, "%f"); else sprintf (str, "%s %s", str, "%*s"); @@ -90,104 +169,224 @@ main (int argc, char **argv) } } - asprintf (&status, "%s", "Swap used:"); - while (fgets (input_buffer, MAX_INPUT_BUFFER - 1, child_process)) { - sscanf (input_buffer, SWAP_FORMAT, &total, &free); - used = total - free; -/* asprintf (&status, "%s [%d/%d]", status, used, total); */ - total_swap += total; - used_swap += used; - free_swap += free; +/* If different swap command is used for summary switch, need to read format differently */ +# ifdef _AIX + if (!allswaps) { + fgets(input_buffer, MAX_INPUT_BUFFER - 1, child_process); /* Ignore first line */ + sscanf (input_buffer, swap_format, &total_swap, &used_swap); + free_swap = total_swap * (100 - used_swap) /100; + used_swap = total_swap - free_swap; + if (verbose >= 3) + printf (_("total=%.0f, used=%.0f, free=%.0f\n"), total_swap, used_swap, free_swap); + } else { +# endif + while (fgets (input_buffer, MAX_INPUT_BUFFER - 1, child_process)) { + sscanf (input_buffer, swap_format, &dsktotal, &dskfree); + + dsktotal = dsktotal / conv_factor; + /* AIX lists percent used, so this converts to dskfree in MBs */ +# ifdef _AIX + dskfree = dsktotal * (100 - dskfree) / 100; +# else + dskfree = dskfree / conv_factor; +# endif + if (verbose >= 3) + printf (_("total=%.0f, free=%.0f\n"), dsktotal, dskfree); + + dskused = dsktotal - dskfree; + total_swap += dsktotal; + used_swap += dskused; + free_swap += dskfree; + if (allswaps) { + percent = 100 * (((double) dskused) / ((double) dsktotal)); + result = max_state (result, check_swap (percent, dskfree)); + if (verbose) + asprintf (&status, "%s [%.0f (%d%%)]", status, dskfree, 100 - percent); + } + } +# ifdef _AIX } - percent_used = 100 * ((float) used_swap) / ((float) total_swap); - asprintf (&status, "%s %2d%% (%d out of %d)", - status, percent_used, used_swap, total_swap); - if (percent_used >= crit_percent || free_swap <= crit_size) - result = STATE_CRITICAL; - else if (percent_used >= warn_percent || free_swap <= warn_size) - result = STATE_WARNING; +# endif /* If we get anything on STDERR, at least set warning */ while (fgets (input_buffer, MAX_INPUT_BUFFER - 1, child_stderr)) - result = max (result, STATE_WARNING); + result = max_state (result, STATE_WARNING); /* close stderr */ (void) fclose (child_stderr); /* close the pipe */ if (spclose (child_process)) - result = max (result, STATE_WARNING); -#endif -#endif + result = max_state (result, STATE_WARNING); +# else +# ifdef CHECK_SWAP_SWAPCTL_SVR4 + + /* get the number of active swap devices */ + nswaps=swapctl(SC_GETNSWP, NULL); + + /* initialize swap table + entries */ + tbl=(swaptbl_t*)malloc(sizeof(swaptbl_t)+(sizeof(swapent_t)*nswaps)); + memset(tbl, 0, sizeof(swaptbl_t)+(sizeof(swapent_t)*nswaps)); + tbl->swt_n=nswaps; + for(i=0;iswt_ent[i]; + ent->ste_path=(char*)malloc(sizeof(char)*MAXPATHLEN); + } -#ifndef SWAP_COMMAND -#ifndef SWAP_FILE -#ifndef HAVE_PROC_MEMINFO - return STATE_UNKNOWN; -#endif -#endif -#endif + /* and now, tally 'em up */ + swapctl_res=swapctl(SC_LIST, tbl); + if(swapctl_res < 0){ + perror(_("swapctl failed: ")); + result = STATE_WARNING; + } + + for(i=0;iswt_ent[i].ste_pages / SWAP_CONVERSION; + dskfree = (float) tbl->swt_ent[i].ste_free / SWAP_CONVERSION; + dskused = ( dsktotal - dskfree ); + + if (verbose >= 3) + printf ("dsktotal=%.0f dskfree=%.0f dskused=%.0f\n", dsktotal, dskfree, dskused); + + if(allswaps && dsktotal > 0){ + percent = 100 * (((double) dskused) / ((double) dsktotal)); + result = max_state (result, check_swap (percent, dskfree)); + if (verbose) { + asprintf (&status, "%s [%.0f (%d%%)]", status, dskfree, 100 - percent); + } + } + + total_swap += dsktotal; + free_swap += dskfree; + used_swap += dskused; + } + + /* and clean up after ourselves */ + for(i=0;iswt_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: ")); + result = STATE_WARNING; + } + + for(i=0;ise_nblks / conv_factor; + dskused = (float) ent->se_inuse / conv_factor; + dskfree = ( dsktotal - dskused ); + + if(allswaps && dsktotal > 0){ + percent = 100 * (((double) dskused) / ((double) dsktotal)); + result = max_state (result, check_swap (percent, dskfree)); + if (verbose) { + asprintf (&status, "%s [%.0f (%d%%)]", status, dskfree, 100 - percent); + } + } + + total_swap += dsktotal; + free_swap += dskfree; + used_swap += dskused; + } + + /* 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 (result == STATE_OK) - printf ("Swap ok - %s\n", status); - else if (result == STATE_CRITICAL) - printf ("CRITICAL - %s\n", status); - else if (result == STATE_WARNING) - printf ("WARNING - %s\n", status); - else if (result == STATE_UNKNOWN) - printf ("Unable to read output\n"); - else { - result = STATE_UNKNOWN; - printf ("UNKNOWN - %s\n", status); + /* if total_swap == 0, let's not divide by 0 */ + if(total_swap) { + percent_used = 100 * ((double) used_swap) / ((double) total_swap); + } else { + percent_used = 0; } + result = max_state (result, check_swap (percent_used, free_swap)); + printf (_("SWAP %s - %d%% free (%.0f MB out of %.0f MB) %s|"), + state_text (result), + (100 - percent_used), free_swap, total_swap, status); + + puts (perfdata ("swap", (long) free_swap, "MB", + TRUE, (long) max (warn_size/1024, warn_percent/100.0*total_swap), + TRUE, (long) max (crit_size/1024, crit_percent/100.0*total_swap), + TRUE, 0, + TRUE, (long) total_swap)); + return result; } +int +check_swap (int usp, float free_swap) +{ + int result = STATE_UNKNOWN; + free_swap = free_swap * 1024; /* Convert back to bytes as warn and crit specified in bytes */ + if (usp >= 0 && crit_percent != 0 && usp >= (100.0 - crit_percent)) + result = STATE_CRITICAL; + else if (crit_size > 0 && free_swap <= crit_size) + result = STATE_CRITICAL; + else if (usp >= 0 && warn_percent != 0 && usp >= (100.0 - warn_percent)) + result = STATE_WARNING; + else if (warn_size > 0 && free_swap <= warn_size) + result = STATE_WARNING; + else if (usp >= 0.0) + result = STATE_OK; + return result; +} + /* process command-line arguments */ int process_arguments (int argc, char **argv) { - int c, i = 0; + int c = 0; /* option character */ -#ifdef HAVE_GETOPT_H - int option_index = 0; - static struct option long_options[] = { + int option = 0; + static struct option longopts[] = { {"warning", required_argument, 0, 'w'}, {"critical", required_argument, 0, 'c'}, + {"allswaps", no_argument, 0, 'a'}, {"verbose", no_argument, 0, 'v'}, {"version", no_argument, 0, 'V'}, {"help", no_argument, 0, 'h'}, {0, 0, 0, 0} }; -#endif if (argc < 2) return ERROR; while (1) { -#ifdef HAVE_GETOPT_H - c = getopt_long (argc, argv, "+?Vhc:w:", long_options, &option_index); -#else - c = getopt (argc, argv, "+?Vhc:w:"); -#endif + c = getopt_long (argc, argv, "+?Vvhac:w:", longopts, &option); if (c == -1 || c == EOF) break; switch (c) { - case 'w': /* warning time threshold */ + case 'w': /* warning size threshold */ if (is_intnonneg (optarg)) { - warn_size = atoi (optarg); + warn_size = (double) atoi (optarg); break; } else if (strstr (optarg, ",") && strstr (optarg, "%") && - sscanf (optarg, "%d,%d%%", &warn_size, &warn_percent) == 2) { + sscanf (optarg, "%g,%d%%", &warn_size, &warn_percent) == 2) { + warn_size = floor(warn_size); break; } else if (strstr (optarg, "%") && @@ -195,16 +394,17 @@ process_arguments (int argc, char **argv) break; } else { - usage ("Warning threshold must be integer or percentage!\n"); + usage4 (_("Warning threshold must be integer or percentage!")); } - case 'c': /* critical time threshold */ + case 'c': /* critical size threshold */ if (is_intnonneg (optarg)) { - crit_size = atoi (optarg); + crit_size = (double) atoi (optarg); break; } else if (strstr (optarg, ",") && strstr (optarg, "%") && - sscanf (optarg, "%d,%d%%", &crit_size, &crit_percent) == 2) { + sscanf (optarg, "%g,%d%%", &crit_size, &crit_percent) == 2) { + crit_size = floor(crit_size); break; } else if (strstr (optarg, "%") && @@ -212,103 +412,110 @@ process_arguments (int argc, char **argv) break; } else { - usage ("Critical threshold must be integer or percentage!\n"); + usage4 (_("Critical threshold must be integer or percentage!")); } + case 'a': /* all swap */ + allswaps = TRUE; + break; + case 'v': /* verbose */ + verbose++; + break; case 'V': /* version */ - print_revision (my_basename (argv[0]), "$Revision$"); + print_revision (progname, revision); exit (STATE_OK); case 'h': /* help */ print_help (); exit (STATE_OK); - case '?': /* help */ - usage ("Invalid argument\n"); + case '?': /* error */ + usage2 (_("Unknown argument"), optarg); } } c = optind; if (c == argc) return validate_arguments (); - if (warn_percent > 100 && is_intnonneg (argv[c])) + if (warn_percent == 0 && is_intnonneg (argv[c])) warn_percent = atoi (argv[c++]); if (c == argc) return validate_arguments (); - if (crit_percent > 100 && is_intnonneg (argv[c])) + if (crit_percent == 0 && is_intnonneg (argv[c])) crit_percent = atoi (argv[c++]); if (c == argc) return validate_arguments (); - if (warn_size < 0 && is_intnonneg (argv[c])) - warn_size = atoi (argv[c++]); + if (warn_size == 0 && is_intnonneg (argv[c])) + warn_size = (double) atoi (argv[c++]); if (c == argc) return validate_arguments (); - if (crit_size < 0 && is_intnonneg (argv[c])) - crit_size = atoi (argv[c++]); + if (crit_size == 0 && is_intnonneg (argv[c])) + crit_size = (double) atoi (argv[c++]); return validate_arguments (); } - - int validate_arguments (void) { - if (warn_percent > 100 && crit_percent > 100 && warn_size < 0 - && crit_size < 0) { + if (warn_percent == 0 && crit_percent == 0 && warn_size == 0 + && crit_size == 0) { return ERROR; } - else if (warn_percent > crit_percent) { - usage - ("Warning percentage should not be less than critical percentage\n"); + else if (warn_percent < crit_percent) { + usage4 + (_("Warning percentage should be more than critical percentage")); } else if (warn_size < crit_size) { - usage - ("Warning free space should not be more than critical free space\n"); + usage4 + (_("Warning free space should be more than critical free space")); } return OK; } - - void -print_usage (void) +print_help (void) { - printf - ("Usage: check_swap -w %% -c %%\n" - " check_swap -w -c \n" - " check_swap (-V|--version)\n" " check_swap (-h|--help)\n"); -} + print_revision (progname, revision); + + printf (_(COPYRIGHT), copyright, email); + + printf (_("Check swap space on local machine.\n\n")); + print_usage (); + printf (_(UT_HELP_VRSN)); + + printf (_("\n\ + -w, --warning=INTEGER\n\ + Exit with WARNING status if less than INTEGER bytes of swap space are free\n\ + -w, --warning=PERCENT%%\n\ + Exit with WARNING status if less than PERCENT of swap space is free\n\ + -c, --critical=INTEGER\n\ + Exit with CRITICAL status if less than INTEGER bytes of swap space are free\n\ + -c, --critical=PERCENT%%\n\ + Exit with CRITCAL status if less than PERCENT of swap space is free\n\ + -a, --allswaps\n\ + Conduct comparisons for all swap partitions, one by one\n\ + -v, --verbose\n\ + Verbose output. Up to 3 levels\n")); + + printf (_("\n\ +On AIX, if -a is specified, uses lsps -a, otherwise uses lsps -s.\n")); + + printf (_(UT_SUPPORT)); +} void -print_help (void) +print_usage (void) { - print_revision (PROGNAME, "$Revision$"); - printf - ("Copyright (c) 2000 Karl DeBisschop\n\n" - "This plugin will check all of the swap partitions and return an\n" - "error if the the avalable swap space is less than specified.\n\n"); - print_usage (); - printf - ("\nOptions:\n" - " -w, --warning=INTEGER\n" - " Exit with WARNING status if less than INTEGER bytes of swap space are free\n" - " -w, --warning=PERCENT%%\n" - " Exit with WARNING status if more than PERCENT of swap space has been used\n" - " -c, --critical=INTEGER\n" - " Exit with CRITICAL status if less than INTEGER bytes of swap space are free\n" - " -c, --critical=PERCENT%%\n" - " Exit with CRITCAL status if more than PERCENT of swap space has been used\n" - " -h, --help\n" - " Print detailed help screen\n" - " -V, --version\n" " Print version information\n\n"); - support (); + printf ("\ +Usage: %s [-av] -w %% -c %%\n\ + %s [-av] -w -c \n", progname, progname); }