summaryrefslogtreecommitdiffstats
path: root/plugins/check_swap.c
diff options
context:
space:
mode:
Diffstat (limited to 'plugins/check_swap.c')
-rw-r--r--plugins/check_swap.c280
1 files changed, 159 insertions, 121 deletions
diff --git a/plugins/check_swap.c b/plugins/check_swap.c
index 4d5a4071..7da26cfc 100644
--- a/plugins/check_swap.c
+++ b/plugins/check_swap.c
@@ -34,6 +34,9 @@ const char *email = "devel@monitoring-plugins.org";
34#include "common.h" 34#include "common.h"
35#include "popen.h" 35#include "popen.h"
36#include "utils.h" 36#include "utils.h"
37#include <string.h>
38#include <math.h>
39#include <libintl.h>
37 40
38#ifdef HAVE_DECL_SWAPCTL 41#ifdef HAVE_DECL_SWAPCTL
39# ifdef HAVE_SYS_PARAM_H 42# ifdef HAVE_SYS_PARAM_H
@@ -51,16 +54,19 @@ const char *email = "devel@monitoring-plugins.org";
51# define SWAP_CONVERSION 1 54# define SWAP_CONVERSION 1
52#endif 55#endif
53 56
54int check_swap (int usp, float free_swap_mb); 57typedef struct {
58 int is_percentage;
59 uint64_t value;
60} threshold_t;
61
62int check_swap (float free_swap_mb, float total_swap_mb);
55int process_arguments (int argc, char **argv); 63int process_arguments (int argc, char **argv);
56int validate_arguments (void); 64int validate_arguments (void);
57void print_usage (void); 65void print_usage (void);
58void print_help (void); 66void print_help (void);
59 67
60int warn_percent = 0; 68threshold_t warn;
61int crit_percent = 0; 69threshold_t crit;
62float warn_size_bytes = 0;
63float crit_size_bytes = 0;
64int verbose; 70int verbose;
65int allswaps; 71int allswaps;
66int no_swap_state = STATE_CRITICAL; 72int no_swap_state = STATE_CRITICAL;
@@ -68,9 +74,10 @@ int no_swap_state = STATE_CRITICAL;
68int 74int
69main (int argc, char **argv) 75main (int argc, char **argv)
70{ 76{
71 int percent_used, percent; 77 unsigned int percent_used, percent;
72 float total_swap_mb = 0, used_swap_mb = 0, free_swap_mb = 0; 78 uint64_t total_swap_mb = 0, used_swap_mb = 0, free_swap_mb = 0;
73 float dsktotal_mb = 0, dskused_mb = 0, dskfree_mb = 0, tmp_mb = 0; 79 uint64_t dsktotal_mb = 0, dskused_mb = 0, dskfree_mb = 0;
80 uint64_t tmp_KB = 0;
74 int result = STATE_UNKNOWN; 81 int result = STATE_UNKNOWN;
75 char input_buffer[MAX_INPUT_BUFFER]; 82 char input_buffer[MAX_INPUT_BUFFER];
76#ifdef HAVE_PROC_MEMINFO 83#ifdef HAVE_PROC_MEMINFO
@@ -116,10 +123,15 @@ main (int argc, char **argv)
116 } 123 }
117 fp = fopen (PROC_MEMINFO, "r"); 124 fp = fopen (PROC_MEMINFO, "r");
118 while (fgets (input_buffer, MAX_INPUT_BUFFER - 1, fp)) { 125 while (fgets (input_buffer, MAX_INPUT_BUFFER - 1, fp)) {
119 if (sscanf (input_buffer, "%*[S]%*[w]%*[a]%*[p]%*[:] %f %f %f", &dsktotal_mb, &dskused_mb, &dskfree_mb) == 3) { 126 /*
120 dsktotal_mb = dsktotal_mb / 1048576; /* Apply conversion */ 127 * The following sscanf call looks for a line looking like: "Swap: 123 123 123"
121 dskused_mb = dskused_mb / 1048576; 128 * On which kind of system this format exists, I can not say, but I wanted to
122 dskfree_mb = dskfree_mb / 1048576; 129 * document this for people who are not adapt with sscanf anymore, like me
130 */
131 if (sscanf (input_buffer, "%*[S]%*[w]%*[a]%*[p]%*[:] %lu %lu %lu", &dsktotal_mb, &dskused_mb, &dskfree_mb) == 3) {
132 dsktotal_mb = dsktotal_mb / (1024 * 1024); /* Apply conversion */
133 dskused_mb = dskused_mb / (1024 * 1024);
134 dskfree_mb = dskfree_mb / (1024 * 1024);
123 total_swap_mb += dsktotal_mb; 135 total_swap_mb += dsktotal_mb;
124 used_swap_mb += dskused_mb; 136 used_swap_mb += dskused_mb;
125 free_swap_mb += dskfree_mb; 137 free_swap_mb += dskfree_mb;
@@ -128,21 +140,25 @@ main (int argc, char **argv)
128 percent=100.0; 140 percent=100.0;
129 else 141 else
130 percent = 100 * (((double) dskused_mb) / ((double) dsktotal_mb)); 142 percent = 100 * (((double) dskused_mb) / ((double) dsktotal_mb));
131 result = max_state (result, check_swap (percent, dskfree_mb)); 143 result = max_state (result, check_swap (dskfree_mb, dsktotal_mb));
132 if (verbose) 144 if (verbose)
133 xasprintf (&status, "%s [%.0f (%d%%)]", status, dskfree_mb, 100 - percent); 145 xasprintf (&status, "%s [%lu (%d%%)]", status, dskfree_mb, 100 - percent);
134 } 146 }
135 } 147 }
136 else if (sscanf (input_buffer, "%*[S]%*[w]%*[a]%*[p]%[TotalFre]%*[:] %f %*[k]%*[B]", str, &tmp_mb)) { 148 /*
149 * The following sscanf call looks for lines looking like: "SwapTotal: 123" and "SwapFree: 123"
150 * This format exists at least on Debian Linux with a 5.* kernel
151 */
152 else if (sscanf (input_buffer, "%*[S]%*[w]%*[a]%*[p]%[TotalFre]%*[:] %lu %*[k]%*[B]", str, &tmp_KB)) {
137 if (verbose >= 3) { 153 if (verbose >= 3) {
138 printf("Got %s with %f\n", str, tmp_mb); 154 printf("Got %s with %lu\n", str, tmp_KB);
139 } 155 }
140 /* I think this part is always in Kb, so convert to mb */ 156 /* I think this part is always in Kb, so convert to mb */
141 if (strcmp ("Total", str) == 0) { 157 if (strcmp ("Total", str) == 0) {
142 dsktotal_mb = tmp_mb / 1024; 158 dsktotal_mb = tmp_KB / 1024;
143 } 159 }
144 else if (strcmp ("Free", str) == 0) { 160 else if (strcmp ("Free", str) == 0) {
145 dskfree_mb = tmp_mb / 1024; 161 dskfree_mb = tmp_KB / 1024;
146 } 162 }
147 } 163 }
148 } 164 }
@@ -227,7 +243,7 @@ main (int argc, char **argv)
227 free_swap_mb += dskfree_mb; 243 free_swap_mb += dskfree_mb;
228 if (allswaps) { 244 if (allswaps) {
229 percent = 100 * (((double) dskused_mb) / ((double) dsktotal_mb)); 245 percent = 100 * (((double) dskused_mb) / ((double) dsktotal_mb));
230 result = max_state (result, check_swap (percent, dskfree_mb)); 246 result = max_state (result, check_swap (dskfree_mb, dsktotal_mb));
231 if (verbose) 247 if (verbose)
232 xasprintf (&status, "%s [%.0f (%d%%)]", status, dskfree_mb, 100 - percent); 248 xasprintf (&status, "%s [%.0f (%d%%)]", status, dskfree_mb, 100 - percent);
233 } 249 }
@@ -289,7 +305,7 @@ main (int argc, char **argv)
289 305
290 if(allswaps && dsktotal_mb > 0){ 306 if(allswaps && dsktotal_mb > 0){
291 percent = 100 * (((double) dskused_mb) / ((double) dsktotal_mb)); 307 percent = 100 * (((double) dskused_mb) / ((double) dsktotal_mb));
292 result = max_state (result, check_swap (percent, dskfree_mb)); 308 result = max_state (result, check_swap (dskfree_mb, dsktotal_mb));
293 if (verbose) { 309 if (verbose) {
294 xasprintf (&status, "%s [%.0f (%d%%)]", status, dskfree_mb, 100 - percent); 310 xasprintf (&status, "%s [%.0f (%d%%)]", status, dskfree_mb, 100 - percent);
295 } 311 }
@@ -328,7 +344,7 @@ main (int argc, char **argv)
328 344
329 if(allswaps && dsktotal_mb > 0){ 345 if(allswaps && dsktotal_mb > 0){
330 percent = 100 * (((double) dskused_mb) / ((double) dsktotal_mb)); 346 percent = 100 * (((double) dskused_mb) / ((double) dsktotal_mb));
331 result = max_state (result, check_swap (percent, dskfree_mb)); 347 result = max_state (result, check_swap(dskfree_mb, dsktotal_mb));
332 if (verbose) { 348 if (verbose) {
333 xasprintf (&status, "%s [%.0f (%d%%)]", status, dskfree_mb, 100 - percent); 349 xasprintf (&status, "%s [%.0f (%d%%)]", status, dskfree_mb, 100 - percent);
334 } 350 }
@@ -355,14 +371,19 @@ main (int argc, char **argv)
355 status = "- Swap is either disabled, not present, or of zero size. "; 371 status = "- Swap is either disabled, not present, or of zero size. ";
356 } 372 }
357 373
358 result = max_state (result, check_swap (percent_used, free_swap_mb)); 374 result = max_state (result, check_swap(free_swap_mb, total_swap_mb));
359 printf (_("SWAP %s - %d%% free (%d MB out of %d MB) %s|"), 375 printf (_("SWAP %s - %d%% free (%dMB out of %dMB) %s|"),
360 state_text (result), 376 state_text (result),
361 (100 - percent_used), (int) free_swap_mb, (int) total_swap_mb, status); 377 (100 - percent_used), (int) free_swap_mb, (int) total_swap_mb, status);
362 378
363 puts (perfdata ("swap", (long) free_swap_mb, "MB", 379 uint64_t warn_print = warn.value;
364 TRUE, (long) max (warn_size_bytes/(1024 * 1024), warn_percent/100.0*total_swap_mb), 380 if (warn.is_percentage) warn_print = warn.value * (total_swap_mb *1024 *1024/100);
365 TRUE, (long) max (crit_size_bytes/(1024 * 1024), crit_percent/100.0*total_swap_mb), 381 uint64_t crit_print = crit.value;
382 if (crit.is_percentage) crit_print = crit.value * (total_swap_mb *1024 *1024/100);
383
384 puts (perfdata_uint64 ("swap", free_swap_mb *1024 *1024, "B",
385 TRUE, warn_print,
386 TRUE, crit_print,
366 TRUE, 0, 387 TRUE, 0,
367 TRUE, (long) total_swap_mb)); 388 TRUE, (long) total_swap_mb));
368 389
@@ -370,26 +391,37 @@ main (int argc, char **argv)
370} 391}
371 392
372 393
373
374int 394int
375check_swap (int usp, float free_swap_mb) 395check_swap(float free_swap_mb, float total_swap_mb)
376{ 396{
377 397
378 if (!free_swap_mb) return no_swap_state; 398 if (!total_swap_mb) return no_swap_state;
379 399
380 int result = STATE_UNKNOWN; 400 uint64_t free_swap = free_swap_mb * (1024 * 1024); /* Convert back to bytes as warn and crit specified in bytes */
381 float free_swap = free_swap_mb * (1024 * 1024); /* Convert back to bytes as warn and crit specified in bytes */ 401
382 if (usp >= 0 && crit_percent != 0 && usp >= (100.0 - crit_percent)) 402 if (!crit.is_percentage && crit.value >= free_swap) return STATE_CRITICAL;
383 result = STATE_CRITICAL; 403 if (!warn.is_percentage && warn.value >= free_swap) return STATE_WARNING;
384 else if (crit_size_bytes > 0 && free_swap <= crit_size_bytes) 404
385 result = STATE_CRITICAL; 405
386 else if (usp >= 0 && warn_percent != 0 && usp >= (100.0 - warn_percent)) 406 uint64_t usage_percentage = ((total_swap_mb - free_swap_mb) / total_swap_mb) * 100;
387 result = STATE_WARNING; 407
388 else if (warn_size_bytes > 0 && free_swap <= warn_size_bytes) 408 if (crit.is_percentage &&
389 result = STATE_WARNING; 409 usage_percentage >= 0 &&
390 else if (usp >= 0.0) 410 crit.value != 0 &&
391 result = STATE_OK; 411 usage_percentage >= (100 - crit.value))
392 return result; 412 {
413 return STATE_CRITICAL;
414 }
415
416 if (warn.is_percentage &&
417 usage_percentage >= 0 &&
418 warn.value != 0 &&
419 usage_percentage >= (100 - warn.value))
420 {
421 return STATE_WARNING;
422 }
423
424 return STATE_OK;
393} 425}
394 426
395 427
@@ -422,42 +454,68 @@ process_arguments (int argc, char **argv)
422 break; 454 break;
423 455
424 switch (c) { 456 switch (c) {
425 case 'w': /* warning size threshold */ 457 case 'w': /* warning size threshold */
426 if (is_intnonneg (optarg)) { 458 {
427 warn_size_bytes = (float) atoi (optarg); 459 /*
428 break; 460 * We expect either a positive integer value without a unit, which means
429 } 461 * the unit is Bytes or a positive integer value and a percentage sign (%),
430 else if (strstr (optarg, ",") && 462 * which means the value must be with 0 and 100 and is relative to the total swap
431 strstr (optarg, "%") && 463 */
432 sscanf (optarg, "%f,%d%%", &warn_size_bytes, &warn_percent) == 2) { 464 size_t length;
433 warn_size_bytes = floorf(warn_size_bytes); 465 length = strlen(optarg);
434 break; 466
435 } 467 if (optarg[length - 1] == '%') {
436 else if (strstr (optarg, "%") && 468 /* It's percentage */
437 sscanf (optarg, "%d%%", &warn_percent) == 1) { 469 warn.is_percentage = 1;
438 break; 470 optarg[length - 1] = '\0';
439 } 471 if (is_uint64(optarg, &warn.value)) {
440 else { 472 if (warn.value > 100) {
441 usage4 (_("Warning threshold must be integer or percentage!")); 473 usage4 (_("Warning threshold percentage must be <= 100!"));
442 } 474 } else {
443 case 'c': /* critical size threshold */ 475 break;
444 if (is_intnonneg (optarg)) { 476 }
445 crit_size_bytes = (float) atoi (optarg); 477 }
446 break; 478 } else {
447 } 479 /* It's Bytes */
448 else if (strstr (optarg, ",") && 480 warn.is_percentage = 0;
449 strstr (optarg, "%") && 481 if (is_uint64(optarg, &warn.value)) {
450 sscanf (optarg, "%f,%d%%", &crit_size_bytes, &crit_percent) == 2) { 482 break;
451 crit_size_bytes = floorf(crit_size_bytes); 483 } else {
452 break; 484 usage4 (_("Warning threshold be positive integer or percentage!"));
453 } 485 }
454 else if (strstr (optarg, "%") && 486 }
455 sscanf (optarg, "%d%%", &crit_percent) == 1) {
456 break;
457 }
458 else {
459 usage4 (_("Critical threshold must be integer or percentage!"));
460 } 487 }
488 case 'c': /* critical size threshold */
489 {
490 /*
491 * We expect either a positive integer value without a unit, which means
492 * the unit is Bytes or a positive integer value and a percentage sign (%),
493 * which means the value must be with 0 and 100 and is relative to the total swap
494 */
495 size_t length;
496 length = strlen(optarg);
497
498 if (optarg[length - 1] == '%') {
499 /* It's percentage */
500 crit.is_percentage = 1;
501 optarg[length - 1] = '\0';
502 if (is_uint64(optarg, &crit.value)) {
503 if (crit.value> 100) {
504 usage4 (_("Critical threshold percentage must be <= 100!"));
505 } else {
506 break;
507 }
508 }
509 } else {
510 /* It's Bytes */
511 crit.is_percentage = 0;
512 if (is_uint64(optarg, &crit.value)) {
513 break;
514 } else {
515 usage4 (_("Critical threshold be positive integer or percentage!"));
516 }
517 }
518 }
461 case 'a': /* all swap */ 519 case 'a': /* all swap */
462 allswaps = TRUE; 520 allswaps = TRUE;
463 break; 521 break;
@@ -482,23 +540,6 @@ process_arguments (int argc, char **argv)
482 c = optind; 540 c = optind;
483 if (c == argc) 541 if (c == argc)
484 return validate_arguments (); 542 return validate_arguments ();
485 if (warn_percent == 0 && is_intnonneg (argv[c]))
486 warn_percent = atoi (argv[c++]);
487
488 if (c == argc)
489 return validate_arguments ();
490 if (crit_percent == 0 && is_intnonneg (argv[c]))
491 crit_percent = atoi (argv[c++]);
492
493 if (c == argc)
494 return validate_arguments ();
495 if (warn_size_bytes == 0 && is_intnonneg (argv[c]))
496 warn_size_bytes = (float) atoi (argv[c++]);
497
498 if (c == argc)
499 return validate_arguments ();
500 if (crit_size_bytes == 0 && is_intnonneg (argv[c]))
501 crit_size_bytes = (float) atoi (argv[c++]);
502 543
503 return validate_arguments (); 544 return validate_arguments ();
504} 545}
@@ -508,17 +549,15 @@ process_arguments (int argc, char **argv)
508int 549int
509validate_arguments (void) 550validate_arguments (void)
510{ 551{
511 if (warn_percent == 0 && crit_percent == 0 && warn_size_bytes == 0 552 if (warn.value == 0 && crit.value == 0) {
512 && crit_size_bytes == 0) {
513 return ERROR; 553 return ERROR;
514 } 554 }
515 else if (warn_percent < crit_percent) { 555 else if ((warn.is_percentage == crit.is_percentage) && (warn.value < crit.value)) {
516 usage4 556 /* This is NOT triggered if warn and crit are different units, e.g warn is percentage
517 (_("Warning percentage should be more than critical percentage")); 557 * and crit is absolut. We cannot determine the condition at this point since we
518 } 558 * dont know the value of total swap yet
519 else if (warn_size_bytes < crit_size_bytes) { 559 */
520 usage4 560 usage4(_("Warning should be more than critical"));
521 (_("Warning free space should be more than critical free space"));
522 } 561 }
523 return OK; 562 return OK;
524} 563}
@@ -534,7 +573,7 @@ print_help (void)
534 573
535 printf ("%s\n", _("Check swap space on local machine.")); 574 printf ("%s\n", _("Check swap space on local machine."));
536 575
537 printf ("\n\n"); 576 printf ("\n\n");
538 577
539 print_usage (); 578 print_usage ();
540 579
@@ -542,33 +581,32 @@ print_help (void)
542 printf (UT_EXTRA_OPTS); 581 printf (UT_EXTRA_OPTS);
543 582
544 printf (" %s\n", "-w, --warning=INTEGER"); 583 printf (" %s\n", "-w, --warning=INTEGER");
545 printf (" %s\n", _("Exit with WARNING status if less than INTEGER bytes of swap space are free")); 584 printf (" %s\n", _("Exit with WARNING status if less than INTEGER bytes of swap space are free"));
546 printf (" %s\n", "-w, --warning=PERCENT%%"); 585 printf (" %s\n", "-w, --warning=PERCENT%");
547 printf (" %s\n", _("Exit with WARNING status if less than PERCENT of swap space is free")); 586 printf (" %s\n", _("Exit with WARNING status if less than PERCENT of swap space is free"));
548 printf (" %s\n", "-c, --critical=INTEGER"); 587 printf (" %s\n", "-c, --critical=INTEGER");
549 printf (" %s\n", _("Exit with CRITICAL status if less than INTEGER bytes of swap space are free")); 588 printf (" %s\n", _("Exit with CRITICAL status if less than INTEGER bytes of swap space are free"));
550 printf (" %s\n", "-c, --critical=PERCENT%%"); 589 printf (" %s\n", "-c, --critical=PERCENT%");
551 printf (" %s\n", _("Exit with CRITICAL status if less than PERCENT of swap space is free")); 590 printf (" %s\n", _("Exit with CRITICAL status if less than PERCENT of swap space is free"));
552 printf (" %s\n", "-a, --allswaps"); 591 printf (" %s\n", "-a, --allswaps");
553 printf (" %s\n", _("Conduct comparisons for all swap partitions, one by one")); 592 printf (" %s\n", _("Conduct comparisons for all swap partitions, one by one"));
554 printf (" %s\n", "-n, --no-swap=<ok|warning|critical|unknown>"); 593 printf (" %s\n", "-n, --no-swap=<ok|warning|critical|unknown>");
555 printf (" %s %s\n", _("Resulting state when there is no swap regardless of thresholds. Default:"), state_text(no_swap_state)); 594 printf (" %s %s\n", _("Resulting state when there is no swap regardless of thresholds. Default:"), state_text(no_swap_state));
556 printf (UT_VERBOSE); 595 printf (UT_VERBOSE);
557 596
558 printf ("\n"); 597 printf ("\n");
559 printf ("%s\n", _("Notes:")); 598 printf ("%s\n", _("Notes:"));
560 printf (" %s\n", _("Both INTEGER and PERCENT thresholds can be specified, they are all checked.")); 599 printf (" %s\n", _("Both INTEGER and PERCENT thresholds can be specified, they are all checked."));
561 printf (" %s\n", _("On AIX, if -a is specified, uses lsps -a, otherwise uses lsps -s.")); 600 printf (" %s\n", _("On AIX, if -a is specified, uses lsps -a, otherwise uses lsps -s."));
562 601
563 printf (UT_SUPPORT); 602 printf (UT_SUPPORT);
564} 603}
565 604
566 605
567
568void 606void
569print_usage (void) 607print_usage (void)
570{ 608{
571 printf ("%s\n", _("Usage:")); 609 printf ("%s\n", _("Usage:"));
572 printf (" %s [-av] -w <percent_free>%% -c <percent_free>%%\n",progname); 610 printf (" %s [-av] -w <percent_free>%% -c <percent_free>%%\n",progname);
573 printf (" -w <bytes_free> -c <bytes_free> [-n <state>]\n"); 611 printf (" -w <bytes_free> -c <bytes_free> [-n <state>]\n");
574} 612}