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

SNMP编程

开发平台:

Unix_Linux

  1. /*
  2.  * memory_netbsd1.c
  3.  */
  4. #include <net-snmp/net-snmp-config.h>
  5. /*
  6.  * Ripped from /usr/scr/usr.bin/vmstat/vmstat.c (covering all bases) 
  7.  */
  8. #include <sys/param.h>
  9. #include <sys/time.h>
  10. #include <sys/proc.h>
  11. #include <sys/dkstat.h>
  12. #include <sys/buf.h>
  13. #include <sys/uio.h>
  14. #include <sys/namei.h>
  15. #include <sys/malloc.h>
  16. #include <sys/signal.h>
  17. #include <sys/fcntl.h>
  18. #include <sys/ioctl.h>
  19. #include <sys/sysctl.h>
  20. #include <sys/vmmeter.h>
  21.  
  22. #if defined(HAVE_UVM_UVM_PARAM_H) && defined(HAVE_UVM_UVM_EXTERN_H)
  23. #include <uvm/uvm_param.h>
  24. #include <uvm/uvm_extern.h>
  25. #elif defined(HAVE_VM_VM_PARAM_H) && defined(HAVE_VM_VM_EXTERN_H)
  26. #include <vm/vm_param.h>
  27. #include <vm/vm_extern.h>
  28. #else
  29. #error memory_netbsd1.c: Is this really a NetBSD system?
  30. #endif
  31.  
  32. #include <time.h>
  33. #include <nlist.h>
  34. #include <kvm.h>
  35. #include <errno.h>
  36. #include <unistd.h>
  37. #include <stdio.h>
  38. #include <ctype.h>
  39. #include <stdlib.h>
  40. #include <string.h>
  41. #include <paths.h>
  42. #include <limits.h>
  43. #if HAVE_DMALLOC_H
  44. #include <dmalloc.h>
  45. #endif
  46. #include <net-snmp/net-snmp-includes.h>
  47. #include <net-snmp/agent/net-snmp-agent-includes.h>
  48. #include <net-snmp/agent/auto_nlist.h>
  49. #include "util_funcs.h"
  50. #include "memory.h"
  51. #include "memory_netbsd1.h"
  52. /*
  53.  * Default swap warning limit (kb) 
  54.  */
  55. #define DEFAULTMINIMUMSWAP 16000
  56. /*
  57.  * Swap warning limit 
  58.  */
  59. long            minimumswap;
  60. /*
  61.  * Swap info 
  62.  */
  63. quad_t          swapTotal;
  64. quad_t          swapUsed;
  65. quad_t          swapFree;
  66. static FindVarMethod var_extensible_mem;
  67. void
  68. init_memory_netbsd1(void)
  69. {
  70.     struct variable2 extensible_mem_variables[] = {
  71.         {MIBINDEX, ASN_INTEGER, RONLY, var_extensible_mem, 1, {MIBINDEX}},
  72.         {ERRORNAME, ASN_OCTET_STR, RONLY, var_extensible_mem, 1,
  73.          {ERRORNAME}},
  74.         {MEMTOTALSWAP, ASN_INTEGER, RONLY, var_extensible_mem, 1,
  75.          {MEMTOTALSWAP}},
  76.         {MEMAVAILSWAP, ASN_INTEGER, RONLY, var_extensible_mem, 1,
  77.          {MEMAVAILSWAP}},
  78.         {MEMTOTALREAL, ASN_INTEGER, RONLY, var_extensible_mem, 1,
  79.          {MEMTOTALREAL}},
  80.         {MEMAVAILREAL, ASN_INTEGER, RONLY, var_extensible_mem, 1,
  81.          {MEMAVAILREAL}},
  82.         {MEMTOTALSWAPTXT, ASN_INTEGER, RONLY, var_extensible_mem, 1,
  83.          {MEMTOTALSWAPTXT}},
  84.         {MEMUSEDSWAPTXT, ASN_INTEGER, RONLY, var_extensible_mem, 1,
  85.          {MEMUSEDSWAPTXT}},
  86.         {MEMTOTALREALTXT, ASN_INTEGER, RONLY, var_extensible_mem, 1,
  87.          {MEMTOTALREALTXT}},
  88.         {MEMUSEDREALTXT, ASN_INTEGER, RONLY, var_extensible_mem, 1,
  89.          {MEMUSEDREALTXT}},
  90.         {MEMTOTALFREE, ASN_INTEGER, RONLY, var_extensible_mem, 1,
  91.          {MEMTOTALFREE}},
  92.         {MEMSWAPMINIMUM, ASN_INTEGER, RONLY, var_extensible_mem, 1,
  93.          {MEMSWAPMINIMUM}},
  94.         {MEMSHARED, ASN_INTEGER, RONLY, var_extensible_mem, 1,
  95.          {MEMSHARED}},
  96.         {MEMBUFFER, ASN_INTEGER, RONLY, var_extensible_mem, 1,
  97.          {MEMBUFFER}},
  98.         {MEMCACHED, ASN_INTEGER, RONLY, var_extensible_mem, 1,
  99.          {MEMCACHED}},
  100.         {ERRORFLAG, ASN_INTEGER, RONLY, var_extensible_mem, 1,
  101.          {ERRORFLAG}},
  102.         {ERRORMSG, ASN_OCTET_STR, RONLY, var_extensible_mem, 1, {ERRORMSG}}
  103.     };
  104.     /*
  105.      * Define the OID pointer to the top of the mib tree that we're
  106.      * registering underneath 
  107.      */
  108.     oid             mem_variables_oid[] = { UCDAVIS_MIB, MEMMIBNUM };
  109.     /*
  110.      * register ourselves with the agent to handle our mib tree 
  111.      */
  112.     REGISTER_MIB("ucd-snmp/memory", extensible_mem_variables, variable2,
  113.                  mem_variables_oid);
  114.     snmpd_register_config_handler("swap", memory_parse_config,
  115.                                   memory_free_config, "min-avail");
  116. }
  117. void
  118. memory_parse_config(const char *token, char *cptr)
  119. {
  120.     minimumswap = atoi(cptr);
  121. }
  122. void
  123. memory_free_config(void)
  124. {
  125.     minimumswap = DEFAULTMINIMUMSWAP;
  126. }
  127. /*
  128.  * var_extensible_mem(...
  129.  * Arguments:
  130.  * vp     IN      - pointer to variable entry that points here
  131.  * name    IN/OUT  - IN/name requested, OUT/name found
  132.  * length  IN/OUT  - length of IN/OUT oid's 
  133.  * exact   IN      - TRUE if an exact match was requested
  134.  * var_len OUT     - length of variable or 0 if function returned
  135.  * write_method
  136.  * 
  137.  */
  138. static
  139. unsigned char  *
  140. var_extensible_mem(struct variable *vp,
  141.                    oid * name,
  142.                    size_t * length,
  143.                    int exact,
  144.                    size_t * var_len, WriteMethod ** write_method)
  145. {
  146.     static long     long_ret;
  147.     static char     errmsg[1024];
  148.     static struct uvmexp uvmexp;
  149.     int             uvmexp_size = sizeof(uvmexp);
  150.     int             uvmexp_mib[] = { CTL_VM, VM_UVMEXP };
  151.     static struct vmtotal total;
  152.     size_t          total_size = sizeof(total);
  153.     int             total_mib[] = { CTL_VM, VM_METER };
  154.     long            phys_mem;
  155.     size_t          phys_mem_size = sizeof(phys_mem);
  156.     int             phys_mem_mib[] = { CTL_HW, HW_USERMEM };
  157.     if (header_generic(vp, name, length, exact, var_len, write_method))
  158.         return (NULL);
  159.     /*
  160.      * Memory info 
  161.      */
  162.     sysctl(uvmexp_mib, 2, &uvmexp, &uvmexp_size, NULL, 0);
  163.     sysctl(total_mib, 2, &total, &total_size, NULL, 0);
  164.     /*
  165.      * Physical memory 
  166.      */
  167.     sysctl(phys_mem_mib, 2, &phys_mem, &phys_mem_size, NULL, 0);
  168.     long_ret = 0;               /* set to 0 as default */
  169.     /*
  170.      * Page-to-kb macro 
  171.      */
  172. #define ptok(p) ((p) * (uvmexp.pagesize >> 10))
  173.     switch (vp->magic) {
  174.     case MIBINDEX:
  175.         long_ret = 0;
  176.         return ((u_char *) (&long_ret));
  177.     case ERRORNAME:            /* dummy name */
  178.         sprintf(errmsg, "swap");
  179.         *var_len = strlen(errmsg);
  180.         return ((u_char *) (errmsg));
  181.     case MEMTOTALSWAP:
  182.         long_ret = ptok(uvmexp.swpages);
  183.         return ((u_char *) (&long_ret));
  184.     case MEMAVAILSWAP:         /* FREE swap memory */
  185.         long_ret = ptok(uvmexp.swpages - uvmexp.swpginuse);
  186.         return ((u_char *) (&long_ret));
  187.     case MEMTOTALREAL:
  188.         long_ret = phys_mem >> 10;
  189.         return ((u_char *) (&long_ret));
  190.     case MEMAVAILREAL:         /* FREE real memory */
  191.         long_ret = ptok(uvmexp.free);
  192.         return ((u_char *) (&long_ret));
  193.         /*
  194.          * these are not implemented 
  195.          */
  196.     case MEMTOTALSWAPTXT:
  197.     case MEMUSEDSWAPTXT:
  198.     case MEMTOTALREALTXT:
  199.     case MEMUSEDREALTXT:
  200. #if NO_DUMMY_VALUES
  201.         return NULL;
  202. #endif
  203.         long_ret = -1;
  204.         return ((u_char *) (&long_ret));
  205.     case MEMTOTALFREE:
  206.         long_ret = ptok((int) total.t_free);
  207.         return ((u_char *) (&long_ret));
  208.     case MEMSWAPMINIMUM:
  209.         long_ret = minimumswap;
  210.         return ((u_char *) (&long_ret));
  211.     case MEMSHARED:
  212.         return ((u_char *) (&long_ret));
  213.     case MEMBUFFER:
  214.         return NULL;
  215.     case MEMCACHED:
  216.         return NULL;
  217.     case ERRORFLAG:
  218.         long_ret = (swapFree > minimumswap) ? 0 : 1;
  219.         return ((u_char *) (&long_ret));
  220.     case ERRORMSG:
  221.         if (swapFree < minimumswap)
  222.             sprintf(errmsg, "Running out of swap space (%qd)", swapFree);
  223.         else
  224.             errmsg[0] = 0;
  225.         *var_len = strlen(errmsg);
  226.         return ((u_char *) (errmsg));
  227.     }
  228.     return NULL;
  229. }