Back to index

nagios-plugins  1.4.16
Defines | Functions | Variables
check_swap.c File Reference
#include "common.h"
#include "popen.h"
#include "utils.h"

Go to the source code of this file.

Defines

#define SWAP_CONVERSION   1

Functions

int check_swap (int usp, float free_swap_mb)
int process_arguments (int argc, char **argv)
int validate_arguments (void)
void print_usage (void)
void print_help (void)
int main (int argc, char **argv)

Variables

const char * progname = "check_swap"
const char * copyright = "2000-2007"
const char * email = "nagiosplug-devel@lists.sourceforge.net"
int warn_percent = 0
int crit_percent = 0
float warn_size_bytes = 0
float crit_size_bytes = 0
int verbose
int allswaps

Define Documentation

#define SWAP_CONVERSION   1

Definition at line 51 of file check_swap.c.


Function Documentation

int check_swap ( int  usp,
float  free_swap_mb 
)

Definition at line 373 of file check_swap.c.

{
       int result = STATE_UNKNOWN;
       float free_swap = free_swap_mb * (1024 * 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_bytes > 0 && free_swap <= crit_size_bytes)
              result = STATE_CRITICAL;
       else if (usp >= 0 && warn_percent != 0 && usp >= (100.0 - warn_percent))
              result = STATE_WARNING;
       else if (warn_size_bytes > 0 && free_swap <= warn_size_bytes)
              result = STATE_WARNING;
       else if (usp >= 0.0)
              result = STATE_OK;
       return result;
}

Here is the caller graph for this function:

int main ( int  argc,
char **  argv 
)

Definition at line 68 of file check_swap.c.

{
       int percent_used, percent;
       float total_swap_mb = 0, used_swap_mb = 0, free_swap_mb = 0;
       float dsktotal_mb = 0, dskused_mb = 0, dskfree_mb = 0, tmp_mb = 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;

       setlocale (LC_ALL, "");
       bindtextdomain (PACKAGE, LOCALEDIR);
       textdomain (PACKAGE);

       status = strdup ("");

       /* Parse extra opts if any */
       argv=np_extra_opts (&argc, argv, progname);

       if (process_arguments (argc, argv) == ERROR)
              usage4 (_("Could not parse arguments"));

#ifdef HAVE_PROC_MEMINFO
       if (verbose >= 3) {
              printf("Reading PROC_MEMINFO at %s\n", PROC_MEMINFO);
       }
       fp = fopen (PROC_MEMINFO, "r");
       while (fgets (input_buffer, MAX_INPUT_BUFFER - 1, fp)) {
              if (sscanf (input_buffer, "%*[S]%*[w]%*[a]%*[p]%*[:] %f %f %f", &dsktotal_mb, &dskused_mb, &dskfree_mb) == 3) {
                     dsktotal_mb = dsktotal_mb / 1048576;      /* Apply conversion */
                     dskused_mb = dskused_mb / 1048576;
                     dskfree_mb = dskfree_mb / 1048576;
                     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 (percent, dskfree_mb));
                            if (verbose)
                                   asprintf (&status, "%s [%.0f (%d%%)]", status, dskfree_mb, 100 - percent);
                     }
              }
              else if (sscanf (input_buffer, "%*[S]%*[w]%*[a]%*[p]%[TotalFre]%*[:] %f %*[k]%*[B]", str, &tmp_mb)) {
                     if (verbose >= 3) {
                            printf("Got %s with %f\n", str, tmp_mb);
                     }
                     /* I think this part is always in Kb, so convert to mb */
                     if (strcmp ("Total", str) == 0) {
                            dsktotal_mb = tmp_mb / 1024;
                     }
                     else if (strcmp ("Free", str) == 0) {
                            dskfree_mb = tmp_mb / 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
       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);
              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);

       sprintf (str, "%s", "");
       /* 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, "%f");
                     else if (strstr (temp_buffer, "dskfree"))
                            sprintf (str, "%s %s", str, "%f");
                     else
                            sprintf (str, "%s %s", str, "%*s");
                     temp_buffer = strtok (NULL, " \n");
              }
       }

/* 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_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 (verbose >= 3)
                     printf (_("total=%.0f, used=%.0f, free=%.0f\n"), total_swap_mb, used_swap_mb, free_swap_mb);
       } else {
#  endif
              while (fgets (input_buffer, MAX_INPUT_BUFFER - 1, child_process)) {
                     sscanf (input_buffer, swap_format, &dsktotal_mb, &dskfree_mb);

                     dsktotal_mb = dsktotal_mb / conv_factor;
                     /* AIX lists percent used, so this converts to dskfree in MBs */
#  ifdef _AIX
                     dskfree_mb = dsktotal_mb * (100 - dskfree_mb) / 100;
#  else
                     dskfree_mb = dskfree_mb / conv_factor;
#  endif
                     if (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;
                     if (allswaps) {
                            percent = 100 * (((double) dskused_mb) / ((double) dsktotal_mb));
                            result = max_state (result, check_swap (percent, dskfree_mb));
                            if (verbose)
                                   asprintf (&status, "%s [%.0f (%d%%)]", status, dskfree_mb, 100 - percent);
                     }
              }
#  ifdef _AIX
       }
#  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);
# else
#  ifdef CHECK_SWAP_SWAPCTL_SVR4

       /* 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(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"));
       }

       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 (verbose >= 3)
                     printf ("dsktotal_mb=%.0f dskfree_mb=%.0f dskused_mb=%.0f\n", dsktotal_mb, dskfree_mb, dskused_mb);

              if(allswaps && dsktotal_mb > 0){
                     percent = 100 * (((double) dskused_mb) / ((double) dsktotal_mb));
                     result = max_state (result, check_swap (percent, dskfree_mb));
                     if (verbose) {
                            asprintf (&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 */
       for(i=0;i<nswaps;i++){
              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<nswaps;i++){
              dsktotal_mb = (float) ent[i].se_nblks / conv_factor;
              dskused_mb = (float) ent[i].se_inuse / conv_factor;
              dskfree_mb = ( dsktotal_mb - dskused_mb );

              if(allswaps && dsktotal_mb > 0){
                     percent = 100 * (((double) dskused_mb) / ((double) dsktotal_mb));
                     result = max_state (result, check_swap (percent, dskfree_mb));
                     if (verbose) {
                            asprintf (&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 = 0;
       }

       result = max_state (result, check_swap (percent_used, free_swap_mb));
       printf (_("SWAP %s - %d%% free (%d MB out of %d MB) %s|"),
                     state_text (result),
                     (100 - percent_used), (int) free_swap_mb, (int) total_swap_mb, status);

       puts (perfdata ("swap", (long) free_swap_mb, "MB",
                       TRUE, (long) max (warn_size_bytes/(1024 * 1024), warn_percent/100.0*total_swap_mb),
                       TRUE, (long) max (crit_size_bytes/(1024 * 1024), crit_percent/100.0*total_swap_mb),
                       TRUE, 0,
                       TRUE, (long) total_swap_mb));

       return result;
}

Here is the call graph for this function:

void print_help ( void  )
void print_usage ( void  )

Definition at line 389 of file check_cpqarray.c.

{
  printf("cpqarrayd [options]\n");
  printf("   -h         prints this text\n");
  printf("   -d         enables debugging\n");
}
int process_arguments ( int  argc,
char **  argv 
)
int validate_arguments ( void  )

Variable Documentation

int allswaps

Definition at line 65 of file check_swap.c.

const char* copyright = "2000-2007"

Definition at line 31 of file check_swap.c.

int crit_percent = 0

Definition at line 61 of file check_swap.c.

float crit_size_bytes = 0

Definition at line 63 of file check_swap.c.

const char* email = "nagiosplug-devel@lists.sourceforge.net"

Definition at line 32 of file check_swap.c.

const char* progname = "check_swap"

Definition at line 30 of file check_swap.c.

int verbose

Definition at line 64 of file check_swap.c.

int warn_percent = 0

Definition at line 60 of file check_swap.c.

float warn_size_bytes = 0

Definition at line 62 of file check_swap.c.