userapps/opensource/net-snmp/agent/mibgroup/ucd-snmp/memory_dynix.c

   1 #include <net-snmp/net-snmp-config.h>
   2
   3 #ifdef dynix
   4 #  ifdef HAVE_SYS_SWAP_H
   5 #    include <sys/swap.h>
   6 #  endif
   7 #  ifdef HAVE_SYS_PARAM_H
   8 #    include <sys/param.h>
   9 #  endif
  10 #  ifdef HAVE_UNISTD_H
  11 #    include <unistd.h>
  12 #  endif
  13 #endif
  14
  15 #include <net-snmp/net-snmp-includes.h>
  16 #include <net-snmp/agent/net-snmp-agent-includes.h>
  17 #include <net-snmp/agent/auto_nlist.h>
  18
  19
  20 #include "util_funcs.h"         /* utility function declarations */
  21 #include "memory.h"             /* the module-specific header */
  22 #include "memory_dynix.h"       /* the module-specific header */
  23
  24 int             minimumswap;
  25 static char     errmsg[300];
  26
  27 static FindVarMethod var_extensible_mem;
  28 static long     getFreeSwap(void);
  29 static long     getTotalSwap(void);
  30 static long     getTotalFree(void);
  31
  32 void
  33 init_memory_dynix(void)
  34 {
  35
  36     struct variable2 extensible_mem_variables[] = {
  37         {MIBINDEX, ASN_INTEGER, RONLY, var_extensible_mem, 1, {MIBINDEX}},
  38         {ERRORNAME, ASN_OCTET_STR, RONLY, var_extensible_mem, 1,
  39          {ERRORNAME}},
  40         {MEMTOTALSWAP, ASN_INTEGER, RONLY, var_extensible_mem, 1,
  41          {MEMTOTALSWAP}},
  42         {MEMAVAILSWAP, ASN_INTEGER, RONLY, var_extensible_mem, 1,
  43          {MEMAVAILSWAP}},
  44         {MEMTOTALREAL, ASN_INTEGER, RONLY, var_extensible_mem, 1,
  45          {MEMTOTALREAL}},
  46         {MEMAVAILREAL, ASN_INTEGER, RONLY, var_extensible_mem, 1,
  47          {MEMAVAILREAL}},
  48         {MEMTOTALSWAPTXT, ASN_INTEGER, RONLY, var_extensible_mem, 1,
  49          {MEMTOTALSWAPTXT}},
  50         {MEMUSEDSWAPTXT, ASN_INTEGER, RONLY, var_extensible_mem, 1,
  51          {MEMUSEDSWAPTXT}},
  52         {MEMTOTALREALTXT, ASN_INTEGER, RONLY, var_extensible_mem, 1,
  53          {MEMTOTALREALTXT}},
  54         {MEMUSEDREALTXT, ASN_INTEGER, RONLY, var_extensible_mem, 1,
  55          {MEMUSEDREALTXT}},
  56         {MEMTOTALFREE, ASN_INTEGER, RONLY, var_extensible_mem, 1,
  57          {MEMTOTALFREE}},
  58         {MEMSWAPMINIMUM, ASN_INTEGER, RONLY, var_extensible_mem, 1,
  59          {MEMSWAPMINIMUM}},
  60         {MEMSHARED, ASN_INTEGER, RONLY, var_extensible_mem, 1,
  61          {MEMSHARED}},
  62         {MEMBUFFER, ASN_INTEGER, RONLY, var_extensible_mem, 1,
  63          {MEMBUFFER}},
  64         {MEMCACHED, ASN_INTEGER, RONLY, var_extensible_mem, 1,
  65          {MEMCACHED}},
  66         {ERRORFLAG, ASN_INTEGER, RONLY, var_extensible_mem, 1,
  67          {ERRORFLAG}},
  68         {ERRORMSG, ASN_OCTET_STR, RONLY, var_extensible_mem, 1, {ERRORMSG}}
  69     };
  70
  71     /*
  72      * Define the OID pointer to the top of the mib tree that we're
  73      * registering underneath
  74      */
  75     oid             mem_variables_oid[] = { UCDAVIS_MIB, MEMMIBNUM };
  76
  77     /*
  78      * register ourselves with the agent to handle our mib tree
  79      */
  80     REGISTER_MIB("ucd-snmp/memory", extensible_mem_variables, variable2,
  81                  mem_variables_oid);
  82
  83     snmpd_register_config_handler("swap", memory_parse_config,
  84                                   memory_free_config, "min-avail");
  85
  86 }
  87
  88 static u_char  *
  89 var_extensible_mem(struct variable *vp,
  90                    oid * name,
  91                    size_t * length,
  92                    int exact,
  93                    size_t * var_len, WriteMethod ** write_method)
  94 {
  95     static long     long_ret;
  96
  97     /*
  98      * Initialize the return value to 0
  99      */
 100     long_ret = 0;
 101
 102     if (header_generic(vp, name, length, exact, var_len, write_method))
 103         return (NULL);
 104
 105     switch (vp->magic) {
 106     case MIBINDEX:
 107         long_ret = 0;
 108         return ((u_char *) (&long_ret));
 109     case ERRORNAME:            /* dummy name */
 110         sprintf(errmsg, "swap");
 111         *var_len = strlen(errmsg);
 112         return ((u_char *) (errmsg));
 113     case MEMTOTALSWAP:
 114         long_ret = S2KB(getTotalSwap());
 115         return ((u_char *) (&long_ret));
 116     case MEMAVAILSWAP:
 117         long_ret = S2KB(getFreeSwap());
 118         return ((u_char *) (&long_ret));
 119     case MEMSWAPMINIMUM:
 120         long_ret = minimumswap;
 121         return ((u_char *) (&long_ret));
 122     case MEMTOTALREAL:
 123         long_ret = P2KB(sysconf(_SC_PHYSMEM));
 124         return ((u_char *) (&long_ret));
 125     case MEMAVAILREAL:
 126         long_ret = P2KB(sysconf(_SC_FREEMEM));
 127         return ((u_char *) (&long_ret));
 128     case MEMTOTALFREE:
 129         long_ret = getTotalFree();
 130         return ((u_char *) (&long_ret));
 131
 132     case ERRORFLAG:
 133         long_ret = getTotalFree();
 134         long_ret = (long_ret > minimumswap) ? 0 : 1;
 135         return ((u_char *) (&long_ret));
 136
 137     case ERRORMSG:
 138         long_ret = getTotalFree();
 139         if ((long_ret > minimumswap) ? 0 : 1)
 140             sprintf(errmsg, "Running out of swap space (%ld)", long_ret);
 141         else
 142             errmsg[0] = 0;
 143         *var_len = strlen(errmsg);
 144         return ((u_char *) (errmsg));
 145
 146     }
 147
 148     return (NULL);
 149 }
 150
 151 #define DEFAULTMINIMUMSWAP 16384        /* kilobytes */
 152
 153 void
 154 memory_parse_config(const char *token, char *cptr)
 155 {
 156     minimumswap = atoi(cptr);
 157 }
 158
 159 void
 160 memory_free_config(void)
 161 {
 162     minimumswap = DEFAULTMINIMUMSWAP;
 163 }
 164
 165
 166
 167 /*
 168  * return is in sectors
 169  */
 170 long
 171 getTotalSwap(void)
 172 {
 173     long            total_swp_sectors = -1;
 174
 175     size_t          max_elements = MAXSWAPDEVS;
 176     swapsize_t      swap_dblks[MAXSWAPDEVS];
 177     swapstat_t      swap_status;
 178     int             swap_sizes;
 179
 180     if ((swap_sizes =
 181          getswapstat(max_elements, swap_dblks, &swap_status) >= 0))
 182         total_swp_sectors =
 183             swap_dblks[0].sws_size * swap_dblks[0].sws_total;
 184
 185     return (total_swp_sectors);
 186 }
 187
 188 /*
 189  * return is in sectors
 190  */
 191 static long
 192 getFreeSwap(void)
 193 {
 194     long            free_swp_sectors = -1;
 195
 196     size_t          max_elements = MAXSWAPDEVS;
 197     swapsize_t      swap_dblks[MAXSWAPDEVS];
 198     swapstat_t      swap_status;
 199     int             i, swap_sizes;
 200
 201     if ((swap_sizes =
 202          getswapstat(max_elements, swap_dblks, &swap_status) >= 0)) {
 203         for (i = 0; i < swap_sizes; i++)
 204             free_swp_sectors +=
 205                 swap_dblks[0].sws_size * swap_dblks[i].sws_avail;
 206     }
 207
 208     return (free_swp_sectors);
 209 }
 210
 211 /*
 212  * return is in kilobytes
 213  */
 214 static long
 215 getTotalFree(void)
 216 {
 217     long            free_swap = S2KB(getFreeSwap());
 218     long            free_mem = P2KB(sysconf(_SC_FREEMEM));
 219
 220     if (free_swap < 0)
 221         return (free_swap);
 222     if (free_mem < 0)
 223         return (free_mem);
 224
 225     free_mem += free_swap;
 226     return (free_mem);
 227 }