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

SNMP编程

开发平台:

Unix_Linux

  1. /*
  2.  *  vmstat_dynix.c
  3.  *  UCD SNMP module for systemStats section of UCD-SNMP-MIB for Dynix
  4.  *  Patrick Hess <phess@phess.best.vwh.net>
  5.  *
  6.  *  This is just a port of the vmstat_solaris2 code Version 0.7
  7.  *
  8.  */
  9. /*
  10.  * To make lint skip the debug code and stop complaining 
  11.  */
  12. #ifdef __lint
  13. #define SNMP_NO_DEBUGGING 1
  14. #endif
  15. #define __NO_ASM_MACRO 1
  16. /*
  17.  * Includes start here 
  18.  */
  19. #include <net-snmp/net-snmp-config.h>
  20. /*
  21.  * Standard includes 
  22.  */
  23. #include <sys/tmp_ctl.h>
  24. #include <sys/sysperf.h>
  25. #include <sys/vmmeter.h>
  26. #include <unistd.h>
  27. #include <string.h>
  28. #include <net-snmp/net-snmp-includes.h>
  29. #include <net-snmp/agent/net-snmp-agent-includes.h>
  30. #include "mibdefs.h"
  31. #include "util_funcs.h"
  32. /*
  33.  * Header file for this module 
  34.  */
  35. #include "vmstat.h"
  36. #include "vmstat_dynix.h"
  37. /*
  38.  * Includes end here 
  39.  */
  40. /*
  41.  * Global structures start here 
  42.  */
  43. /*
  44.  * A structure to save data gathered from the kernel kstat interface to.  
  45.  */
  46. /*
  47.  * We used to have the sys/sysinfo.h cpu_stat_t here but we did not need 
  48.  */
  49. /*
  50.  * all of it, some in a different size and some additional ones so we build 
  51.  */
  52. /*
  53.  * our own 
  54.  */
  55. struct cpu_stat_snapshot {
  56.     time_t          css_time;
  57.     unsigned int    css_cpus;
  58.     unsigned long long css_swapin;
  59.     unsigned long long css_swapout;
  60.     unsigned long long css_blocks_read;
  61.     unsigned long long css_blocks_write;
  62.     unsigned long long css_interrupts;
  63.     unsigned long long css_context_sw;
  64.     unsigned long long css_cpu[V_CPU_STATES];
  65. };
  66. /*
  67.  * Global structures end here 
  68.  */
  69. /*
  70.  * Global variables start here 
  71.  */
  72. /*
  73.  * Variables for the calculated values, filled in update_stats    
  74.  */
  75. /*
  76.  * Need to be global since we need them in more than one function 
  77.  */
  78. static ulong    swapin;
  79. static ulong    swapout;
  80. static ulong    blocks_read;
  81. static ulong    blocks_write;
  82. static ulong    interrupts;
  83. static ulong    context_sw;
  84. /*
  85.  * Since MIB wants V_CPU_SYSTEM, which is V_CPU_KERNEL + V_CPU_STREAM 
  86.  */
  87. static long     cpu_perc[V_CPU_STATES + 1];
  88. /*
  89.  * How many snapshots we have already taken, needed for the first 
  90.  */
  91. /*
  92.  * POLL_INTERVAL * POLL_VALUES seconds of agent running 
  93.  */
  94. static unsigned int number_of_snapshots;
  95. /*
  96.  * The place to store the snapshots of system data in 
  97.  */
  98. static struct cpu_stat_snapshot snapshot[POLL_VALUES + 1];
  99. /*
  100.  * And one for the raw counters, which we fill when the raw values are 
  101.  */
  102. /*
  103.  * requested, as opposed to the absolute values, which are taken every 
  104.  */
  105. /*
  106.  * POLL_INTERVAL seconds and calculated over POLL_INTERVAL * POLL_VALUES time 
  107.  */
  108. static struct cpu_stat_snapshot raw_values;
  109. /*
  110.  * Global variables end here 
  111.  */
  112. /*
  113.  * Functions start here 
  114.  */
  115. /*
  116.  * Function prototype 
  117.  */
  118. static void     update_stats(unsigned int registrationNumber,
  119.                              void *clientarg);
  120. static int      take_snapshot(struct cpu_stat_snapshot *css);
  121. /*
  122.  * init_vmstat_dynix starts here 
  123.  */
  124. /*
  125.  * Init function for this module, from prototype 
  126.  */
  127. /*
  128.  * Defines variables handled by this module, defines root OID for 
  129.  */
  130. /*
  131.  * this module and registers it with the agent 
  132.  */
  133. FindVarMethod var_extensible_vmstat;
  134. void
  135. init_vmstat_dynix(void)
  136. {
  137.     /*
  138.      * Which variables do we service ? 
  139.      */
  140.     struct variable2 extensible_vmstat_variables[] = {
  141.         {MIBINDEX, ASN_INTEGER, RONLY, var_extensible_vmstat, 1,
  142.          {MIBINDEX}},
  143.         {ERRORNAME, ASN_OCTET_STR, RONLY, var_extensible_vmstat, 1,
  144.          {ERRORNAME}},
  145.         {SWAPIN, ASN_INTEGER, RONLY, var_extensible_vmstat, 1, {SWAPIN}},
  146.         {SWAPOUT, ASN_INTEGER, RONLY, var_extensible_vmstat, 1, {SWAPOUT}},
  147.         {IOSENT, ASN_INTEGER, RONLY, var_extensible_vmstat, 1, {IOSENT}},
  148.         {IORECEIVE, ASN_INTEGER, RONLY, var_extensible_vmstat, 1,
  149.          {IORECEIVE}},
  150.         {SYSINTERRUPTS, ASN_INTEGER, RONLY, var_extensible_vmstat, 1,
  151.          {SYSINTERRUPTS}},
  152.         {SYSCONTEXT, ASN_INTEGER, RONLY, var_extensible_vmstat, 1,
  153.          {SYSCONTEXT}},
  154.         {CPUUSER, ASN_INTEGER, RONLY, var_extensible_vmstat, 1, {CPUUSER}},
  155.         {CPUSYSTEM, ASN_INTEGER, RONLY, var_extensible_vmstat, 1,
  156.          {CPUSYSTEM}},
  157.         {CPUIDLE, ASN_INTEGER, RONLY, var_extensible_vmstat, 1, {CPUIDLE}},
  158.         {CPURAWUSER, ASN_COUNTER, RONLY, var_extensible_vmstat, 1,
  159.          {CPURAWUSER}},
  160.         {CPURAWSYSTEM, ASN_COUNTER, RONLY, var_extensible_vmstat, 1,
  161.          {CPURAWSYSTEM}},
  162.         {CPURAWIDLE, ASN_COUNTER, RONLY, var_extensible_vmstat, 1,
  163.          {CPURAWIDLE}},
  164.         {CPURAWWAIT, ASN_COUNTER, RONLY, var_extensible_vmstat, 1,
  165.          {CPURAWWAIT}},
  166.         {CPURAWKERNEL, ASN_COUNTER, RONLY, var_extensible_vmstat, 1,
  167.          {CPURAWKERNEL}},
  168.         {IORAWSENT, ASN_COUNTER, RONLY, var_extensible_vmstat, 1,
  169.          {IORAWSENT}},
  170.         {IORAWRECEIVE, ASN_COUNTER, RONLY, var_extensible_vmstat, 1,
  171.          {IORAWRECEIVE}},
  172.         /*
  173.          * Future use: 
  174.          */
  175.         /*
  176.          * {ERRORFLAG, ASN_INTEGER, RONLY, var_extensible_vmstat, 1, {ERRORFLAG }},
  177.          * {ERRORMSG, ASN_OCTET_STR, RONLY, var_extensible_vmstat, 1, {ERRORMSG }}
  178.          */
  179.     };
  180.     /*
  181.      * Define the OID pointer to the top of the mib tree that we're 
  182.      */
  183.     /*
  184.      * registering underneath 
  185.      */
  186.     oid             vmstat_variables_oid[] = { UCDAVIS_MIB, 11 };
  187.     /*
  188.      * register ourselves with the agent to handle our mib tree 
  189.      */
  190.     /*
  191.      * LINTED Trust me, I know what I'm doing 
  192.      */
  193.     REGISTER_MIB("ucd-snmp/vmstat", extensible_vmstat_variables, variable2,
  194.                  vmstat_variables_oid);
  195.     /*
  196.      * Start with some useful data 
  197.      */
  198.     update_stats(0, NULL);
  199.     /*
  200.      * update_stats is run every POLL_INTERVAL seconds using this routine 
  201.      */
  202.     /*
  203.      * (see 'man snmp_alarm') 
  204.      */
  205.     /*
  206.      * This is only executed once to get some useful data in the beginning 
  207.      */
  208.     if (snmp_alarm_register(5, NULL, update_stats, NULL) == 0) {
  209.         snmp_log(LOG_WARNING,
  210.                  "vmstat_dynix (init): snmp_alarm_register failed.n");
  211.     }
  212.     /*
  213.      * This is the one that runs update_stats every POLL_INTERVAL seconds 
  214.      */
  215.     if (snmp_alarm_register(POLL_INTERVAL, SA_REPEAT, update_stats, NULL)
  216.         == 0) {
  217.         snmp_log(LOG_ERR,
  218.                  "vmstat_dynix (init): snmp_alarm_register failed, cannot service requests.n");
  219.     }
  220. }                               /* init_vmstat_dynix ends here */
  221. /*
  222.  * Data collection function take_snapshot starts here 
  223.  */
  224. /*
  225.  * Get data from kernel and save into the snapshot strutcs 
  226.  */
  227. /*
  228.  * Argument is the snapshot struct to save to. Global anyway, but looks nicer 
  229.  */
  230. static int
  231. take_snapshot(struct cpu_stat_snapshot *css)
  232. {
  233.     /*
  234.      * Variables start here 
  235.      */
  236.     /*
  237.      * Counters 
  238.      */
  239.     unsigned int    cpu_num = 0;
  240.     /*
  241.      * Low resolution time counter 
  242.      */
  243.     time_t          current_time;
  244.     /*
  245.      * see sys/sysperf.h, holds CPU data 
  246.      */
  247.     exp_vmmeter_t  *cs, *origcs = 0;
  248.     /*
  249.      * size of the cs struct 
  250.      */
  251.     size_t          vminfo_size;
  252.     /*
  253.      * The usual stuff to count on, err, by 
  254.      */
  255.     int             i;
  256.     int             engnum = 0;
  257.     /*
  258.      * Variables end here 
  259.      */
  260.     /*
  261.      * Function starts here 
  262.      */
  263.     /*
  264.      * Get time 
  265.      */
  266.     current_time = time(0);
  267.     /*
  268.      * If we have just gotten the data, return the values from last run (skip if-clause) 
  269.      */
  270.     /*
  271.      * This happens on a snmpwalk request. 
  272.      */
  273.     /*
  274.      * if we just did it less than 2 seconds ago 
  275.      */
  276.     /*
  277.      * Jumps into if-clause either when snapshot is empty or when too old 
  278.      */
  279.     if ((css->css_time == 0) || (current_time > css->css_time + 2)) {
  280.         /*
  281.          * Make sure we clean up before we put new data into snapshot 
  282.          */
  283.         memset(css, 0, sizeof *css);
  284.         /*
  285.          * Get the number of CPUs we gather data from 
  286.          */
  287.         if ((cpu_num = tmp_ctl(TMP_NENG, 0)) < 0) {
  288.             snmp_log(LOG_ERR,
  289.                      "vmstat_dynix: (take snapshot) bad tmp_ctl returnn");
  290.             return (-1);
  291.         }
  292.         css->css_cpus = cpu_num;
  293.         vminfo_size = cpu_num * sizeof(exp_vmmeter_t);
  294.         if (!(cs = (exp_vmmeter_t *) malloc(vminfo_size))) {
  295.             snmp_log(LOG_ERR,
  296.                      "vmstat_dynix: (take_snapshot) bad malloc returnn");
  297.             return (-1);
  298.         }
  299.         origcs = cs;
  300.         /*
  301.          * Update timer 
  302.          */
  303.         css->css_time = current_time;
  304.         /*
  305.          * Read data from kernel into cs structure 
  306.          */
  307.         /*
  308.          * cs is the buffer we are writing to and 
  309.          */
  310.         /*
  311.          * vminfo_size is the size of the cs struct 
  312.          */
  313.         if ((getkerndata(VMMETER_DATAID, cs, vminfo_size)) < 0) {
  314.             snmp_log(LOG_ERR,
  315.                      "vmstat_dynix (take_snapshot): getkerndata failure.");
  316.             return (-1);
  317.         }
  318.         /*
  319.          * Get the data from each CPU 
  320.          */
  321.         /*
  322.          * We walk through the whole vmmeter struct and sum up all the found stats, 
  323.          */
  324.         /*
  325.          * there's one for every CPU in a machine 
  326.          */
  327.         /*
  328.          * Okay...  you can't laugh at this!  I'm a C-hack, not a C-coder. :)  
  329.          */
  330.         while (engnum < cpu_num) {
  331.             /*
  332.              * Get the data from the cs structure and sum it up in our own structure 
  333.              */
  334.             css->css_swapin += (unsigned long long) cs->v_swpin;
  335.             css->css_swapout += (unsigned long long) cs->v_swpout;
  336.             css->css_blocks_read += (unsigned long long) cs->v_phread;
  337.             css->css_blocks_write += (unsigned long long) cs->v_phwrite;
  338.             css->css_interrupts += (unsigned long long) cs->v_intr;
  339.             css->css_context_sw += (unsigned long long) cs->v_swtch;
  340.             /*
  341.              * We need a for-loop for the CPU STATE values 
  342.              */
  343.             for (i = 0; i < V_CPU_STATES; i++) {
  344.                 css->css_cpu[i] += (unsigned long long) cs->v_time[i];
  345.             }                   /* end for */
  346.             cs++;
  347.             engnum++;
  348.         }                       /* end while */
  349.     }
  350.     free((void *) origcs);
  351.     /*
  352.      * All engines running at warp speed, no problems (if there are any engines, that is) 
  353.      */
  354.     return (cpu_num > 0 ? 0 : -1);
  355. }                               /* take_snapshot ends here */
  356. /*
  357.  * This gets called every POLL_INTERVAL seconds to update the snapshots.  It takes a new snapshot and 
  358.  */
  359. /*
  360.  * drops the oldest one.  This way we move the time window so we always take the values over 
  361.  */
  362. /*
  363.  * POLL_INTERVAL * POLL_VALUES seconds and update the data used every POLL_INTERVAL seconds 
  364.  */
  365. /*
  366.  * The alarm timer is in the init function of this module (snmp_alarm_register) 
  367.  */
  368. /*
  369.  * ARGSUSED0 
  370.  */
  371. static void
  372. update_stats(unsigned int registrationNumber, void *clientarg)
  373. {
  374.     /*
  375.      * The time between the samples we compare 
  376.      */
  377.     time_t          time_diff;
  378.     /*
  379.      * Easier to use these than the snapshots, short hand pointers 
  380.      */
  381.     struct cpu_stat_snapshot *css_old, *css_new;
  382.     /*
  383.      * The usual stuff to count on, err, by 
  384.      */
  385.     int             i;
  386.     /*
  387.      * The sum of the CPU ticks that have passed on the different CPU states, so we can calculate 
  388.      */
  389.     /*
  390.      * the percentages of each state 
  391.      */
  392.     unsigned long long cpu_sum = 0;
  393.     DEBUGMSGTL(("ucd-snmp/vmstat_dynix.c:update_stats",
  394.                 "updating statsn"));
  395.     /*
  396.      * Take the current snapshot 
  397.      */
  398.     if (take_snapshot(&snapshot[0]) == -1) {
  399.         snmp_log(LOG_WARNING,
  400.                  "vmstat_dynix (update_stats): Something went wrong with take_snapshot.");
  401.         return;
  402.     }
  403.     /*
  404.      * Do we have some data we can use ?  An issue right after the start of the agent 
  405.      */
  406.     if (number_of_snapshots > 0) {
  407.         /*
  408.          * Huh, the number of CPUs changed during run time.  That is indeed s.th. worth noting, we 
  409.          */
  410.         /*
  411.          * output a humorous (more or less) syslog message and need to retake the snapshots 
  412.          */
  413.         if (snapshot[0].css_cpus != snapshot[1].css_cpus) {
  414.             if (snapshot[0].css_cpus > snapshot[1].css_cpus) {
  415.                 snmp_log(LOG_NOTICE,
  416.                          "vmstat_dynix (update_stats): Cool ! Number of CPUs increased, must be hot-pluggable.");
  417.             } else {
  418.                 snmp_log(LOG_NOTICE,
  419.                          "vmstat_dynix (update_stats): Lost at least one CPU, RIP.");
  420.             }
  421.             /*
  422.              * Make all snapshots but the current one invalid 
  423.              */
  424.             number_of_snapshots = 1;
  425.             /*
  426.              * Move the current one in the "first" [1] slot 
  427.              */
  428.             memmove(&snapshot[1], &snapshot[0], sizeof snapshot[0]);
  429.             /*
  430.              * Erase the current one 
  431.              */
  432.             memset(&snapshot[0], 0, sizeof snapshot[0]);
  433.             /*
  434.              * Try to get a new snapshot in five seconds so we can return s.th. useful 
  435.              */
  436.             if (snmp_alarm_register(5, NULL, update_stats, NULL) == 0) {
  437.                 snmp_log(LOG_WARNING,
  438.                          "vmstat_dynix (update_stats): snmp_alarm_register failed.n");
  439.             }
  440.             return;
  441.         }
  442.         /*
  443.          * Short hand pointers 
  444.          */
  445.         css_new = &snapshot[0];
  446.         css_old = &snapshot[number_of_snapshots];
  447.         /*
  448.          * How much time has passed between the snapshots we get the values from ? 
  449.          */
  450.         /*
  451.          * Time is in seconds 
  452.          */
  453.         time_diff =
  454.             snapshot[0].css_time - snapshot[number_of_snapshots].css_time;
  455.         if (time_diff == 0)
  456.             DEBUGMSGTL(("ucd-snmp/vmstat_dynix.c:update_stats",
  457.                         "time_diff is ZERO...  watch for the segfaultn"));
  458.         DEBUGMSGTL(("ucd-snmp/vmstat_dynix.c:update_stats",
  459.                     "time_diff: %lldn", time_diff));
  460.         /*
  461.          * swapin and swapout are in pages, MIB wants kB/s,so we just need to get kB and seconds 
  462.          */
  463.         /*
  464.          * For the others we need to get value per second 
  465.          */
  466.         /*
  467.          * decided to use sysconf(_SC_PAGESIZE) instead to get around an #ifndef (I don't like those) 
  468.          */
  469.         /*
  470.          * LINTED cast needed, really 
  471.          */
  472.         swapin =
  473.             (uint_t) ((css_new->css_swapin -
  474.                        css_old->css_swapin) * (time_t) 1000 *
  475.                       sysconf(_SC_PAGESIZE) / 1024 / time_diff);
  476.         /*
  477.          * LINTED cast needed, really 
  478.          */
  479.         swapout =
  480.             (uint_t) ((css_new->css_swapout -
  481.                        css_old->css_swapout) * (time_t) 1000 *
  482.                       sysconf(_SC_PAGESIZE) / 1024 / time_diff);
  483.         /*
  484.          * LINTED cast needed, really 
  485.          */
  486.         blocks_read =
  487.             (uint_t) ((css_new->css_blocks_read -
  488.                        css_old->css_blocks_read) * (time_t) 1000 /
  489.                       time_diff);
  490.         /*
  491.          * LINTED cast needed, really 
  492.          */
  493.         blocks_write =
  494.             (uint_t) ((css_new->css_blocks_write -
  495.                        css_old->css_blocks_write) * (time_t) 1000 /
  496.                       time_diff);
  497.         /*
  498.          * LINTED cast needed, really 
  499.          */
  500.         interrupts =
  501.             (uint_t) ((css_new->css_interrupts -
  502.                        css_old->css_interrupts) * (time_t) 1000 /
  503.                       time_diff);
  504.         /*
  505.          * LINTED cast needed, really 
  506.          */
  507.         context_sw =
  508.             (uint_t) ((css_new->css_context_sw -
  509.                        css_old->css_context_sw) * (time_t) 1000 /
  510.                       time_diff);
  511.         /*
  512.          * Loop thru all the V_CPU_STATES and get the differences 
  513.          */
  514.         for (i = 0; i < V_CPU_STATES; i++) {
  515.             cpu_sum += (css_new->css_cpu[i] - css_old->css_cpu[i]);
  516.         }
  517.         /*
  518.          * Now calculate the absolute percentage values 
  519.          */
  520.         /*
  521.          * Looks somewhat complicated sometimes but tries to get around using floats to increase speed 
  522.          */
  523.         for (i = 0; i < V_CPU_STATES; i++) {
  524.             /*
  525.              * Since we don't return fractions we use + 0.5 to get between 99 and 101 percent adding the values 
  526.              */
  527.             /*
  528.              * together, otherwise we would get less than 100 most of the time 
  529.              */
  530.             /*
  531.              * LINTED has to be 'long' 
  532.              */
  533.             cpu_perc[i] =
  534.                 (long) (((css_new->css_cpu[i] -
  535.                           css_old->css_cpu[i]) * 100 +
  536.                          (cpu_sum / 2)) / cpu_sum);
  537.         }
  538.         /*
  539.          * As said before, MIB wants V_CPU_SYSTEM which is V_CPU_KERNEL + V_CPU_STREAM 
  540.          */
  541.         /*
  542.          * LINTED has to be 'long' 
  543.          */
  544.         cpu_perc[V_CPU_SYSTEM] =
  545.             (long) ((((css_new->css_cpu[V_CPU_KERNEL] -
  546.                        css_old->css_cpu[V_CPU_KERNEL])
  547.                       + (css_new->css_cpu[V_CPU_STREAM] -
  548.                          css_old->css_cpu[V_CPU_STREAM]))
  549.                      * 100 + (cpu_sum / 2)) / cpu_sum);
  550.     }
  551.     /*
  552.      * Make the current one the first one and move the whole thing one place down 
  553.      */
  554.     memmove(&snapshot[1], &snapshot[0],
  555.             (size_t) (((char *) &snapshot[POLL_VALUES]) -
  556.                       ((char *) &snapshot[0])));
  557.     /*
  558.      * Erase the current one 
  559.      */
  560.     memset(&snapshot[0], 0, sizeof snapshot[0]);
  561.     /*
  562.      * Only important on start up, we keep track of how many snapshots we have taken so far 
  563.      */
  564.     if (number_of_snapshots < POLL_VALUES) {
  565.         number_of_snapshots++;
  566.     }
  567. }                               /* update_stats ends here */
  568. /*
  569.  * *var_extensible_vmstat starts here 
  570.  */
  571. /*
  572.  * The guts of the module, this routine gets called to service a request 
  573.  */
  574. unsigned char *
  575. var_extensible_vmstat(struct variable *vp,
  576.                       oid * name,
  577.                       size_t * length,
  578.                       int exact,
  579.                       size_t * var_len, WriteMethod ** write_method)
  580. {
  581.     /*
  582.      * Needed for returning the values 
  583.      */
  584.     static long     long_ret;
  585.     static char     errmsg[300];
  586.     /*
  587.      * set to 0 as default 
  588.      */
  589.     long_ret = 0;
  590.     /*
  591.      * generic check whether the options passed make sense and whether the 
  592.      */
  593.     /*
  594.      * right variable is requested 
  595.      */
  596.     if (header_generic(vp, name, length, exact, var_len, write_method) !=
  597.         MATCH_SUCCEEDED) {
  598.         return (NULL);
  599.     }
  600.     /*
  601.      * The function that actually returns s.th. 
  602.      */
  603.     switch (vp->magic) {
  604.     case MIBINDEX:
  605.         long_ret = 1;
  606.         return ((u_char *) (&long_ret));
  607.     case ERRORNAME:            /* dummy name */
  608.         sprintf(errmsg, "systemStats");
  609.         *var_len = strlen(errmsg);
  610.         return ((u_char *) (errmsg));
  611.     case SWAPIN:
  612.         return ((u_char *) (&swapin));
  613.     case SWAPOUT:
  614.         return ((u_char *) (&swapout));
  615.     case IOSENT:
  616.         return ((u_char *) (&blocks_write));
  617.     case IORECEIVE:
  618.         return ((u_char *) (&blocks_read));
  619.     case SYSINTERRUPTS:
  620.         return ((u_char *) (&interrupts));
  621.     case SYSCONTEXT:
  622.         return ((u_char *) (&context_sw));
  623.     case CPUUSER:
  624.         return ((u_char *) (&cpu_perc[V_CPU_USER]));
  625.     case CPUSYSTEM:
  626.         return ((u_char *) (&cpu_perc[V_CPU_SYSTEM]));
  627.     case CPUIDLE:
  628.         return ((u_char *) (&cpu_perc[V_CPU_IDLE]));
  629.     case CPURAWUSER:
  630.         take_snapshot(&raw_values);
  631.         /*
  632.          * LINTED has to be 'long' 
  633.          */
  634.         long_ret =
  635.             (long) (raw_values.css_cpu[V_CPU_USER] / raw_values.css_cpus);
  636.         return ((u_char *) (&long_ret));
  637.         /*
  638.          * We are missing CPURAWNICE, Dynix does not account for this in the kernel so this OID can not 
  639.          */
  640.         /*
  641.          * be returned.  Also, these values will roll over sooner or later and then return inaccurate data 
  642.          */
  643.         /*
  644.          * but the MIB wants Integer32 so we cannot put a counter here 
  645.          */
  646.         /*
  647.          * (Has been changed to Counter32 in the latest MIB version!) 
  648.          */
  649.     case CPURAWSYSTEM:
  650.         take_snapshot(&raw_values);
  651.         /*
  652.          * LINTED has to be 'long' 
  653.          */
  654.         long_ret =
  655.             (long) ((raw_values.css_cpu[V_CPU_KERNEL] +
  656.                      raw_values.css_cpu[V_CPU_STREAM]) /
  657.                     raw_values.css_cpus);
  658.         return ((u_char *) (&long_ret));
  659.     case CPURAWIDLE:
  660.         take_snapshot(&raw_values);
  661.         /*
  662.          * LINTED has to be 'long' 
  663.          */
  664.         long_ret =
  665.             (long) (raw_values.css_cpu[V_CPU_IDLE] / raw_values.css_cpus);
  666.         return ((u_char *) (&long_ret));
  667.     case CPURAWWAIT:
  668.         take_snapshot(&raw_values);
  669.         /*
  670.          * LINTED has to be 'long' 
  671.          */
  672.         long_ret =
  673.             (long) (raw_values.css_cpu[V_CPU_STREAM] /
  674.                     raw_values.css_cpus);
  675.         return ((u_char *) (&long_ret));
  676.     case CPURAWKERNEL:
  677.         take_snapshot(&raw_values);
  678.         /*
  679.          * LINTED has to be 'long' 
  680.          */
  681.         long_ret =
  682.             (long) (raw_values.css_cpu[V_CPU_KERNEL] /
  683.                     raw_values.css_cpus);
  684.         return ((u_char *) (&long_ret));
  685.     case IORAWSENT:
  686.         long_ret = (long) (raw_values.css_blocks_write);
  687.         return ((u_char *) (&long_ret));
  688.     case IORAWRECEIVE:
  689.         long_ret = (long) (raw_values.css_blocks_read);
  690.         return ((u_char *) (&long_ret));
  691.         /*
  692.          * reserved for future use 
  693.          */
  694.         /*
  695.          * case ERRORFLAG:
  696.          * return((u_char *) (&long_ret));
  697.          * case ERRORMSG:
  698.          * return((u_char *) (&long_ret));
  699.          */
  700.     default:
  701.         snmp_log(LOG_ERR,
  702.                  "vmstat_dynix: Error in request, no match found.n");
  703.     }
  704.     return (NULL);
  705. }                               /* *var_extensible_vmstat ends here */
  706. /*
  707.  * Functions end here 
  708.  */
  709. /*
  710.  * Program ends here 
  711.  */