memory_aix4.c
上传用户:wxp200602
上传日期:2007-10-30
资源大小:4028k
文件大小:7k
源码类别:

SNMP编程

开发平台:

Unix_Linux

  1. /*
  2.  * AIX4 memory statistics module for net-snmp
  3.  *
  4.  * Version 0.1 - Initial release - 05/Jun/2003
  5.  *
  6.  * Derived from memory_solaris2.c
  7.  * Using libperfstat for statistics (Redbook SG24-6039)
  8.  *
  9.  * Ported to AIX by Michael Kukat <michael.kukat@to.com>
  10.  * Thinking Objects Software GmbH
  11.  * Lilienthalstra遝 2
  12.  * 70825 Stuttgart-Korntal
  13.  * http://www.to.com/
  14.  *
  15.  * Thanks go to Jochen Kmietsch for the solaris2 support and
  16.  * to DaimlerChrysler AG Stuttgart for making this port possible
  17.  */
  18. #include <net-snmp/net-snmp-config.h>   /* local SNMP configuration details */
  19. #if HAVE_STRING_H
  20. #include <string.h>
  21. #endif
  22. #if HAVE_STDLIB_H
  23. #include <stdlib.h>
  24. #endif
  25. #include <sys/types.h>
  26. #if HAVE_DMALLOC_H
  27. #include <dmalloc.h>
  28. #endif
  29. #include <net-snmp/net-snmp-includes.h>
  30. #include <net-snmp/agent/net-snmp-agent-includes.h>
  31. #include <net-snmp/agent/auto_nlist.h>
  32. #include "util_funcs.h"         /* utility function declarations */
  33. #include "memory.h"             /* the module-specific header */
  34. #include "memory_aix4.h"    /* the module-specific header */
  35. #include <libperfstat.h>
  36. #include <sys/stat.h>
  37. #include <unistd.h>
  38. #define MAXSTRSIZE 80
  39. int             minimumswap;
  40. static char     errmsg[1024];
  41. static FindVarMethod var_extensible_mem;
  42. static long     getFreeSwap(void);
  43. static long     getTotalFree(void);
  44. static long     getTotalSwap(void);
  45. static long     getFreeReal(void);
  46. static long     getTotalReal(void);
  47. void
  48. init_memory_aix4(void)
  49. {
  50.     struct variable2 extensible_mem_variables[] = {
  51.         {MIBINDEX, ASN_INTEGER, RONLY, var_extensible_mem, 1, {MIBINDEX}},
  52.         {ERRORNAME, ASN_OCTET_STR, RONLY, var_extensible_mem, 1,
  53.          {ERRORNAME}},
  54.         {MEMTOTALSWAP, ASN_INTEGER, RONLY, var_extensible_mem, 1,
  55.          {MEMTOTALSWAP}},
  56.         {MEMAVAILSWAP, ASN_INTEGER, RONLY, var_extensible_mem, 1,
  57.          {MEMAVAILSWAP}},
  58.         {MEMTOTALREAL, ASN_INTEGER, RONLY, var_extensible_mem, 1,
  59.          {MEMTOTALREAL}},
  60.         {MEMAVAILREAL, ASN_INTEGER, RONLY, var_extensible_mem, 1,
  61.          {MEMAVAILREAL}},
  62.         {MEMTOTALSWAPTXT, ASN_INTEGER, RONLY, var_extensible_mem, 1,
  63.          {MEMTOTALSWAPTXT}},
  64.         {MEMUSEDSWAPTXT, ASN_INTEGER, RONLY, var_extensible_mem, 1,
  65.          {MEMUSEDSWAPTXT}},
  66.         {MEMTOTALREALTXT, ASN_INTEGER, RONLY, var_extensible_mem, 1,
  67.          {MEMTOTALREALTXT}},
  68.         {MEMUSEDREALTXT, ASN_INTEGER, RONLY, var_extensible_mem, 1,
  69.          {MEMUSEDREALTXT}},
  70.         {MEMTOTALFREE, ASN_INTEGER, RONLY, var_extensible_mem, 1,
  71.          {MEMTOTALFREE}},
  72.         {MEMSWAPMINIMUM, ASN_INTEGER, RONLY, var_extensible_mem, 1,
  73.          {MEMSWAPMINIMUM}},
  74.         {MEMSHARED, ASN_INTEGER, RONLY, var_extensible_mem, 1,
  75.          {MEMSHARED}},
  76.         {MEMBUFFER, ASN_INTEGER, RONLY, var_extensible_mem, 1,
  77.          {MEMBUFFER}},
  78.         {MEMCACHED, ASN_INTEGER, RONLY, var_extensible_mem, 1,
  79.          {MEMCACHED}},
  80.         {ERRORFLAG, ASN_INTEGER, RONLY, var_extensible_mem, 1,
  81.          {ERRORFLAG}},
  82.         {ERRORMSG, ASN_OCTET_STR, RONLY, var_extensible_mem, 1, {ERRORMSG}}
  83.     };
  84.     /*
  85.      * Define the OID pointer to the top of the mib tree that we're
  86.      * registering underneath 
  87.      */
  88.     oid             mem_variables_oid[] = { UCDAVIS_MIB, MEMMIBNUM };
  89.     /*
  90.      * register ourselves with the agent to handle our mib tree 
  91.      */
  92.     REGISTER_MIB("ucd-snmp/memory", extensible_mem_variables, variable2,
  93.                  mem_variables_oid);
  94.     snmpd_register_config_handler("swap", memory_parse_config,
  95.                                   memory_free_config, "min-avail");
  96. }
  97. static u_char  *
  98. var_extensible_mem(struct variable *vp,
  99.                    oid * name,
  100.                    size_t * length,
  101.                    int exact,
  102.                    size_t * var_len, WriteMethod ** write_method)
  103. {
  104.     static long     long_ret;
  105.     /*
  106.      * Initialize the return value to 0 
  107.      */
  108.     long_ret = 0;
  109.     if (header_generic(vp, name, length, exact, var_len, write_method))
  110.         return (NULL);
  111.     switch (vp->magic) {
  112.     case MIBINDEX:
  113.         long_ret = 0;
  114.         return ((u_char *) (&long_ret));
  115.     case ERRORNAME:            /* dummy name */
  116.         sprintf(errmsg, "swap");
  117.         *var_len = strlen(errmsg);
  118.         return ((u_char *) (errmsg));
  119.     case MEMTOTALSWAP:
  120.         long_ret = getTotalSwap() * (getpagesize() / 1024);
  121.         return ((u_char *) (&long_ret));
  122.     case MEMAVAILSWAP:
  123.         long_ret = getFreeSwap() * (getpagesize() / 1024);
  124.         return ((u_char *) (&long_ret));
  125.     case MEMSWAPMINIMUM:
  126.         long_ret = minimumswap;
  127.         return ((u_char *) (&long_ret));
  128.     case MEMTOTALREAL:
  129.   long_ret = getTotalReal() * (getpagesize() / 1024);
  130.   return ((u_char *) (&long_ret));
  131.     case MEMAVAILREAL:
  132.   long_ret = getFreeReal() * (getpagesize() / 1024);
  133.   return ((u_char *) (&long_ret));
  134.     case MEMTOTALFREE:
  135.         long_ret = getTotalFree() * (getpagesize() / 1024);
  136.         return ((u_char *) (&long_ret));
  137.     case ERRORFLAG:
  138.         long_ret = getTotalFree() * (getpagesize() / 1024);
  139.         long_ret = (long_ret > minimumswap) ? 0 : 1;
  140.         return ((u_char *) (&long_ret));
  141.     case ERRORMSG:
  142.         long_ret = getTotalFree() * (getpagesize() / 1024);
  143.         if ((long_ret > minimumswap) ? 0 : 1)
  144.             sprintf(errmsg, "Running out of swap space (%ld)", long_ret);
  145.         else
  146.             errmsg[0] = 0;
  147.         *var_len = strlen(errmsg);
  148.         return ((u_char *) (errmsg));
  149.     }
  150.     return (NULL);
  151. }
  152. #define DEFAULTMINIMUMSWAP 16000        /* kilobytes */
  153. void
  154. memory_parse_config(const char *token, char *cptr)
  155. {
  156.     minimumswap = atoi(cptr);
  157. }
  158. void
  159. memory_free_config(void)
  160. {
  161.     minimumswap = DEFAULTMINIMUMSWAP;
  162. }
  163. static long
  164. getTotalSwap(void)
  165. {
  166.     long            total_mem = -1;
  167.  perfstat_memory_total_t mem;
  168.  if(perfstat_memory_total((perfstat_id_t *)NULL, &mem, sizeof(perfstat_memory_total_t), 1) >= 1) {
  169.  total_mem = mem.pgsp_total;
  170.  }
  171.     return (total_mem);
  172. }
  173. static long
  174. getFreeSwap(void)
  175. {
  176.     long            free_mem = -1;
  177.  perfstat_memory_total_t mem;
  178.  if(perfstat_memory_total((perfstat_id_t *)NULL, &mem, sizeof(perfstat_memory_total_t), 1) >= 1) {
  179.  free_mem = mem.pgsp_free;
  180.  }
  181.     return (free_mem);
  182. }
  183. static long
  184. getTotalFree(void)
  185. {
  186.     long            free_mem = -1;
  187.  perfstat_memory_total_t mem;
  188.  if(perfstat_memory_total((perfstat_id_t *)NULL, &mem, sizeof(perfstat_memory_total_t), 1) >= 1) {
  189.  free_mem = mem.pgsp_free + mem.real_free;
  190.  }
  191.     return (free_mem);
  192. }
  193. static long
  194. getTotalReal(void)
  195. {
  196.     long            total_mem = -1;
  197.  perfstat_memory_total_t mem;
  198.  if(perfstat_memory_total((perfstat_id_t *)NULL, &mem, sizeof(perfstat_memory_total_t), 1) >= 1) {
  199.  total_mem = mem.real_total;
  200.  }
  201.     return (total_mem);
  202. }
  203. static long
  204. getFreeReal(void)
  205. {
  206.     long            free_mem = -1;
  207.  perfstat_memory_total_t mem;
  208.  if(perfstat_memory_total((perfstat_id_t *)NULL, &mem, sizeof(perfstat_memory_total_t), 1) >= 1) {
  209.  free_mem = mem.real_free;
  210.  }
  211.     return (free_mem);
  212. }