Back to index

nagios-plugins  1.4.16
Classes | Defines | Functions | Variables
check_cpqarray.c File Reference
#include <unistd.h>
#include <sys/ioctl.h>
#include <sys/utsname.h>
#include <stdio.h>
#include <fcntl.h>
#include <string.h>
#include <errno.h>
#include "/usr/src/linux/drivers/block/ida_ioctl.h"
#include "/usr/src/linux/drivers/block/ida_cmd.h"
#include "/usr/src/linux/drivers/block/cpqarray.h"

Go to the source code of this file.

Classes

struct  opts
struct  slog_disk
struct  controller

Defines

#define DEBUG(x)   fprintf(stderr, x)

Functions

int status_check (struct opts opts)
int discover_controllers (struct opts opts)
void boardid2str (unsigned long board_id, char *name)
int interrogate_controller (struct opts opts, int contrnum)
int interrogate_logical (struct opts opts, int devicefd, int unit_nr)
void print_usage ()
int main (int argc, char *argv[])

Variables

const char * controllers []
const char * statusstr []
char * optarg
int optind
int opterr
int optopt
int ctrls_found_num
int exit_code = 0

Class Documentation

struct opts

Definition at line 77 of file check_cpqarray.c.

Class Members
char debug
struct slog_disk

Definition at line 82 of file check_cpqarray.c.

Class Members
float pvalue
int status
struct controller

Definition at line 88 of file check_cpqarray.c.

Class Members
char ctrl_devicename
int num_logd_found

Define Documentation

#define DEBUG (   x)    fprintf(stderr, x)

Definition at line 75 of file check_cpqarray.c.


Function Documentation

void boardid2str ( unsigned long  board_id,
char *  name 
)

Definition at line 229 of file check_cpqarray.c.

{
  switch (board_id)
    {
    case 0x0040110E:        /* IDA */
      strcpy (name, "Compaq IDA");
      break;
    case 0x0140110E:        /* IDA-2 */
      strcpy (name, "Compaq IDA-2");
      break;
    case 0x1040110E:        /* IAES */
      strcpy (name, "Compaq IAES");
      break;
    case 0x2040110E:        /* SMART */
      strcpy (name, "Compaq SMART");
      break;
    case 0x3040110E:        /* SMART-2/E */
      strcpy (name, "Compaq SMART-2/E");
      break;
    case 0x40300E11:        /* SMART-2/P or SMART-2DH */
      strcpy (name, "Compaq SMART-2/P (2DH)");
      break;
    case 0x40310E11:        /* SMART-2SL */
      strcpy (name, "Compaq SMART-2SL");
      break;
    case 0x40320E11:        /* SMART-3200 */
      strcpy (name, "Compaq SMART-3200");
      break;
    case 0x40330E11:        /* SMART-3100ES */
      strcpy (name, "Compaq SMART-3100ES");
      break;
    case 0x40340E11:        /* SMART-221 */
      strcpy (name, "Compaq SMART-221");
      break;
    case 0x40400E11:        /* Integrated Array */
      strcpy (name, "Compaq Integrated Array");
      break;
    case 0x40500E11:        /* Smart Array 4200 */
      strcpy (name, "Compaq Smart Array 4200");
      break;
    case 0x40510E11:        /* Smart Array 4250ES */
      strcpy (name, "Compaq Smart Array 4250ES");
      break;
    case 0x40580E11:        /* Smart Array 431 */
      strcpy (name, "Compaq Smart Array 431");
      break;
    default:
      /*
       * Well, its a SMART-2 or better, don't know which
       * kind.
       */
      strcpy (name, "Unknown Controller Type");
    }
}

Here is the caller graph for this function:

int discover_controllers ( struct opts  opts)

Definition at line 201 of file check_cpqarray.c.

{
  int cntr;
  int foundone = 0;

  for (cntr = 0; cntr < 8; cntr++)
    {
      /* does this device exist ? */
      if ((access (controllers[cntr], R_OK | F_OK)) == 0)
       {
         /* it does :) */
         if (interrogate_controller (opts, cntr))
           {
             foundone = 1;
             if (opts.debug) 
              fprintf (stderr, "DEBUG: %s is a existing controller\n",
                      controllers[cntr]);
           }
       }
      else if (opts.debug)
       {
         fprintf (stderr, "DEBUG: Device %s could not be opened\n", controllers[cntr]);
         perror ("DEBUG: reason");
       }
    }
   return foundone;
}

Here is the call graph for this function:

Here is the caller graph for this function:

int interrogate_controller ( struct opts  opts,
int  contrnum 
)

Definition at line 284 of file check_cpqarray.c.

{
  int devicefd;
  ida_ioctl_t io;
  char buffer[30];
  int foundone = 0;
  int cntr;
 
  devicefd = open (controllers[contrnum], O_RDONLY);
  /* no checks, did that before */

  /* clear io */
  memset (&io, 0, sizeof (io));

  io.cmd = ID_CTLR;

  if (ioctl (devicefd, IDAPASSTHRU, &io) < 0)
    {
      if (opts.debug) perror ("DEBUG: ioctl");
      return 0;
    }

  boardid2str (io.c.id_ctlr.board_id, buffer);

  strncpy (ctrls_found[ctrls_found_num].ctrl_devicename, 
          buffer, 20);

  ctrls_found[ctrls_found_num].num_logd_found = 0;

  for (cntr = 0; cntr < io.c.id_ctlr.nr_drvs; cntr++)
    {
      if (interrogate_logical (opts, devicefd, cntr))
       {
         /* logical drive found, this could be used later one */
         foundone = 1;
       }
    }

  switch (ctrls_found[ctrls_found_num].num_logd_found)
    {
    case 0:
      printf("Found a %s with no logical drives.\n", buffer);
      break;
    case 1:
      printf("Found a %s with one Logical drive.\n", buffer,
       ctrls_found[ctrls_found_num].num_logd_found);
      break;
    default:
      printf("Found a %s with %d Logical drives.\n", buffer,
       ctrls_found[ctrls_found_num].num_logd_found);
      break;
    }

  ctrls_found_num++;

  close (devicefd);
  return 1;
}

Here is the call graph for this function:

Here is the caller graph for this function:

int interrogate_logical ( struct opts  opts,
int  devicefd,
int  unit_nr 
)

Definition at line 343 of file check_cpqarray.c.

{
  ida_ioctl_t io;
  ida_ioctl_t io2;
  int nr_blks, blks_tr;

  if (opts.debug) printf ("DEBUG: interrogating unit %d\n", unit_nr);

  memset (&io, 0, sizeof (io));

  io.cmd = ID_LOG_DRV;
  io.unit = unit_nr | UNITVALID;

  if (ioctl (devicefd, IDAPASSTHRU, &io) < 0)
    {
      perror ("FATAL: ID_LOG_DRV ioctl");
      return 0;
    }

  memset (&io2, 0, sizeof (io2));

  io2.cmd = SENSE_LOG_DRV_STAT;
  io2.unit = unit_nr | UNITVALID;

  if (ioctl (devicefd, IDAPASSTHRU, &io2) < 0)
    {
      perror ("FATAL: SENSE_LOG_DRV_STAT ioctl");
      return 0;
    }
  
  ctrls_found[ctrls_found_num].num_logd_found++;
  /*  ctrls_found[ctrls_found_num].log_disk[unit_nr].status =
   * io2.c.sense_log_drv_stat.status;

   * nr_blks = io2.c.id_log_drv.nr_blks;
   * blks_tr = io.c.sense_log_drv_stat.blks_to_recover;
   * ctrls_found[ctrls_found_num].log_disk[unit_nr].pvalue =
   *  ((float)(nr_blks - blks_tr)/(float)nr_blks) * 100;
   */
  ctrls_found[ctrls_found_num].log_disk[unit_nr].status = 0;
  ctrls_found[ctrls_found_num].log_disk[unit_nr].pvalue = 0;

  return 1;
}

Here is the caller graph for this function:

int main ( int  argc,
char *  argv[] 
)

Definition at line 397 of file check_cpqarray.c.

{
  char option;
  struct opts opts; /* commandline options */
  
  memset(&opts, 0, sizeof(struct opts));
  
  /* check options */
  while ((option = getopt (argc, argv, "dh:")) != EOF)
    {
      switch (option)
        {
       case 'd':
         opts.debug = 1;
         break;
       case '?':
       case 'h':
       default:
         print_usage();
         exit(0);
         break;
       }
    }
  
  /* Check for existance of array controllers */
  if (!discover_controllers(opts)) {
    printf("No array controller found!\n\n");
    exit(1);
  }

  status_check(opts);

  return exit_code;
}

Here is the call graph for this function:

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

Here is the caller graph for this function:

int status_check ( struct opts  opts)

Definition at line 97 of file check_cpqarray.c.

{
  int devicefd;
  int ctrl_cntr;
  int logd_cntr;
  ida_ioctl_t io, io2;
  int status, nr_blks, blks_tr;
  float pvalue;
  int counter;
    
  for ( ctrl_cntr=0;
        ctrl_cntr <  ctrls_found_num;
        ctrl_cntr++) {
    
    devicefd = open (controllers[ctrl_cntr], O_RDONLY);
    
    for ( logd_cntr=0;
          logd_cntr < ctrls_found[ctrl_cntr].num_logd_found;
          logd_cntr++) {
      
        memset (&io, 0, sizeof (io));

        io.cmd = SENSE_LOG_DRV_STAT;
        io.unit = logd_cntr  | UNITVALID;
        
        if (ioctl (devicefd, IDAPASSTHRU, &io) < 0)
          {
            perror ("SENSE_LOG_DRV_STAT ioctl");
            return 0;
          }

        status=io.c.sense_log_drv_stat.status;
        
        if ((status == 3) || (status == 5) || (status == 7)) {
          /* is a progress indicator required?
           */
          memset (&io2, 0, sizeof (io));
          
          io2.cmd = ID_LOG_DRV;
          io2.unit = logd_cntr  | UNITVALID;
          
          if (ioctl (devicefd, IDAPASSTHRU, &io2) < 0)
            {
              perror ("ID_LOG_DRV ioctl");
              /* return 0;   no return this isn't fatal for now */
            }
          else 
            {
              nr_blks = io2.c.id_log_drv.nr_blks;
              blks_tr = io.c.sense_log_drv_stat.blks_to_recover;
                  
              pvalue = ((float)(nr_blks - blks_tr)/(float)nr_blks) * 100;
            }
        }
        else {
          pvalue = 0.0;
        }

        if (opts.debug) {
         fprintf(stdout, "DEBUG: Status of controller %d unit %d is %d\n", 
                ctrl_cntr, logd_cntr, status);
          fprintf(stdout, "DEBUG: ");
         fprintf(stdout, statusstr[status], 
                ctrl_cntr, logd_cntr, pvalue);
         fprintf(stdout, "\n");
       }
       
       printf(statusstr[status], ctrl_cntr, logd_cntr, pvalue);

       switch(status)
         {
         case 1:
         case 2:
         case 6:
         case 7:
         case 9:
           /* CRITICAL */
           exit_code = 2;
           break;
         case 3:
         case 4:
         case 5:
         case 8:
         case 10:
         case 11:
         case 12:
           /* WARNING (only if not yet at CRITICAL LEVEL) */
           if (exit_code < 2) exit_code = 1;
           break;
         case 0:
         default:
           /* do nothing */
           break;
         }

       ctrls_found[ctrl_cntr].log_disk[logd_cntr].pvalue = pvalue;
       ctrls_found[ctrl_cntr].log_disk[logd_cntr].status = status;
    }
    close (devicefd);
  }

  return 1;
}

Here is the call graph for this function:

Here is the caller graph for this function:


Variable Documentation

const char* controllers[]
Initial value:
{
  "/dev/ida/c0d0",
  "/dev/ida/c1d0",
  "/dev/ida/c2d0",
  "/dev/ida/c3d0",
  "/dev/ida/c4d0",
  "/dev/ida/c5d0",
  "/dev/ida/c6d0",
  "/dev/ida/c7d0"
}

Definition at line 40 of file check_cpqarray.c.

Definition at line 71 of file check_cpqarray.c.

int exit_code = 0

Definition at line 72 of file check_cpqarray.c.

char* optarg

Definition at line 67 of file getopt.c.

int opterr

Definition at line 87 of file getopt.c.

int optind

Definition at line 82 of file getopt.c.

int optopt

Definition at line 93 of file getopt.c.

const char* statusstr[]
Initial value:
 {
        "Logical drive /dev/ida/c%dd%d: OK\n",
        "Logical drive /dev/ida/c%dd%d: FAILED\n",
        "Logical drive /dev/ida/c%dd%d: not configured.\n",
        "Logical drive /dev/ida/c%dd%d: using interim recovery mode, %3.2f%% done.\n",
        "Logical drive /dev/ida/c%dd%d: ready for recovery operation.\n",
        "Logical drive /dev/ida/c%dd%d: is currently recovering, %3.2f%% done.\n",
        "Wrong physical drive was replaced.\n",
        "A physical drive is not properly connected.\n",
        "Hardware is overheating.\n",
        "Hardware has overheated.\n",
        "Logical drive /dev/ida/c%dd%d: currently expanding, %3.2f%% done.\n",
        "Logical drive /dev/ida/c%dd%d: not yet available.\n",
        "Logical drive /dev/ida/c%dd%d: queued for expansion.\n",
}

Definition at line 52 of file check_cpqarray.c.