开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Internet/网络编程 > SNMP编程 > 查看源码
hr_proc.c
资源名称：net-snmp-5.2.2.rar　[点击查看]
上传用户：wxp200602
上传日期：2007-10-30
资源大小：4028k
文件大小：14k
源码类别：

SNMP编程

开发平台：

Unix_Linux

hr_proc.c：源码内容
  1. /*
  2.  *  Host Resources MIB - proc processor group implementation - hr_proc.c
  3.  *
  4.  */
  6. #include <net-snmp/net-snmp-config.h>
  7. #if HAVE_STDLIB_H
  8. #include <stdlib.h>
  9. #endif
  10. #if HAVE_STRING_H
  11. #include <string.h>
  12. #else
  13. #include <strings.h>
  14. #endif
  15. #include <ctype.h>
  17. #include "host_res.h"
  18. #include "hr_proc.h"
  19. #include <net-snmp/agent/auto_nlist.h>
  20. #include <net-snmp/agent/agent_read_config.h>
  21. #include "ucd-snmp/loadave.h"
  23. #define HRPROC_MONOTONICALLY_INCREASING
  25.         /*********************
  26.  *
  27.  *  Kernel & interface information,
  28.  *   and internal forward declarations
  29.  *
  30.  *********************/
  32. extern void     Init_HR_Proc(void);
  33. extern int      Get_Next_HR_Proc(void);
  34. const char     *describe_proc(int);
  35. int             header_hrproc(struct variable *, oid *, size_t *, int,
  36.                               size_t *, WriteMethod **);
  37. #ifdef linux
  38. void detect_hrproc(void);
  39. #endif
  41. #ifdef solaris2
  42. #define MAX_NUM_HRPROC  128       /* will handle up to 128 processors */
  43. #include <kstat.h>
  44. #include <kernel_sunos5.h>
  45. hrtime_t  update_time = NULL;
  46. static int ncpus = 0;             /* derived from kstat system_misc ncpus*/
  47. struct cpuinfo {
  48.             int id;
  49.             char state[10];
  50.             int state_begin;
  51.             char cpu_type[15];
  52.             char fpu_type[15];
  53.             int clock_MHz;
  54.             };                    /* derived from kstat cpu_info*/
  55. static struct cpuinfo cpu[MAX_NUM_HRPROC];
  56. static char proc_description[96]; /* buffer to hold description of current cpu*/
  57. extern void kstat_CPU(void);
  58. int proc_status(int);
  59. #else
  60. #define MAX_NUM_HRPROC  32
  61. char proc_descriptions[MAX_NUM_HRPROC][BUFSIZ];
  62. #endif  /*solaris 2*/
  64.         /*********************
  65.  *
  66.  *  Initialisation & common implementation functions
  67.  *
  68.  *********************/
  69. static int      HRP_index;
  70. static int      HRP_max_index = 1;
  72. #define HRPROC_ID 1
  73. #define HRPROC_LOAD 2
  75. struct variable4 hrproc_variables[] = {
  76.     {HRPROC_ID, ASN_OBJECT_ID, RONLY, var_hrproc, 2, {1, 1}},
  77.     {HRPROC_LOAD, ASN_INTEGER, RONLY, var_hrproc, 2, {1, 2}}
  78. };
  79. oid             hrproc_variables_oid[] = { 1, 3, 6, 1, 2, 1, 25, 3, 3 };
  82. void
  83. init_hr_proc(void)
  84. {
  85.     init_device[HRDEV_PROC] = Init_HR_Proc;
  86.     next_device[HRDEV_PROC] = Get_Next_HR_Proc;
  87.     device_descr[HRDEV_PROC] = describe_proc;
  88. #ifdef solaris2
  89.     device_status[HRDEV_PROC] = proc_status;
  90.     update_time = NULL;
  91. #endif
  92. #ifdef HRPROC_MONOTONICALLY_INCREASING
  93.     dev_idx_inc[HRDEV_PROC] = 1;
  94. #endif
  96. #ifdef linux
  97.     detect_hrproc();
  98. #endif
  100.     REGISTER_MIB("host/hr_proc", hrproc_variables, variable4,
  101.                  hrproc_variables_oid);
  102. }
  104. /*
  105.  * header_hrproc(...
  106.  * Arguments:
  107.  * vp     IN      - pointer to variable entry that points here
  108.  * name    IN/OUT  - IN/name requested, OUT/name found
  109.  * length  IN/OUT  - length of IN/OUT oid's 
  110.  * exact   IN      - TRUE if an exact match was requested
  111.  * var_len OUT     - length of variable or 0 if function returned
  112.  * write_method
  113.  * 
  114.  */
  116. int
  117. header_hrproc(struct variable *vp,
  118.               oid * name,
  119.               size_t * length,
  120.               int exact, size_t * var_len, WriteMethod ** write_method)
  121. {
  122. #define HRPROC_ENTRY_NAME_LENGTH 11
  123.     oid             newname[MAX_OID_LEN];
  124.     int             proc_idx, LowIndex = -1;
  125.     int             result;
  127.     DEBUGMSGTL(("host/hr_proc", "var_hrproc: "));
  128.     DEBUGMSGOID(("host/hr_proc", name, *length));
  129.     DEBUGMSG(("host/hr_proc", " %dn", exact));
  131.     memcpy((char *) newname, (char *) vp->name, vp->namelen * sizeof(oid));
  132.     /*
  133.      * Find "next" proc entry 
  134.      */
  136.     Init_HR_Proc();
  137.     for (;;) {
  138.         proc_idx = Get_Next_HR_Proc();
  139.         if (proc_idx == -1)
  140.             break;
  141.         newname[HRPROC_ENTRY_NAME_LENGTH] = proc_idx;
  142.         result = snmp_oid_compare(name, *length, newname, vp->namelen + 1);
  143.         if (exact && (result == 0)) {
  144.             LowIndex = proc_idx;
  145.             /*
  146.              * Save processor status information 
  147.              */
  148.             break;
  149.         }
  150.         if ((!exact && (result < 0)) &&
  151.             (LowIndex == -1 || proc_idx < LowIndex)) {
  152.             LowIndex = proc_idx;
  153.             /*
  154.              * Save processor status information 
  155.              */
  156. #ifdef HRPROC_MONOTONICALLY_INCREASING
  157.             break;
  158. #endif
  159.         }
  160.     }
  162.     if (LowIndex == -1) {
  163.         DEBUGMSGTL(("host/hr_proc", "... index out of rangen"));
  164.         return (MATCH_FAILED);
  165.     }
  167.     memcpy((char *) name, (char *) newname,
  168.            (vp->namelen + 1) * sizeof(oid));
  169.     *length = vp->namelen + 1;
  170.     *write_method = 0;
  171.     *var_len = sizeof(long);    /* default to 'long' results */
  173.     DEBUGMSGTL(("host/hr_proc", "... get proc stats "));
  174.     DEBUGMSGOID(("host/hr_proc", name, *length));
  175.     DEBUGMSG(("host/hr_proc", "n"));
  176.     return LowIndex;
  177. }
  180.         /*********************
  181.  *
  182.  *  System specific implementation functions
  183.  *
  184.  *********************/
  187. u_char         *
  188. var_hrproc(struct variable * vp,
  189.            oid * name,
  190.            size_t * length,
  191.            int exact, size_t * var_len, WriteMethod ** write_method)
  192. {
  193.     int             proc_idx;
  194.     double          avenrun[3];
  196.     proc_idx =
  197.         header_hrproc(vp, name, length, exact, var_len, write_method);
  198.     if (proc_idx == MATCH_FAILED)
  199.         return NULL;
  200.     if (try_getloadavg(&avenrun[0], sizeof(avenrun) / sizeof(avenrun[0]))
  201.         == -1)
  202.         return NULL;
  204.     switch (vp->magic) {
  205.     case HRPROC_ID:
  206.         *var_len = nullOidLen;
  207.         return (u_char *) nullOid;
  208.     case HRPROC_LOAD:
  209. #if NO_DUMMY_VALUES
  210.         return NULL;
  211. #endif
  212.         long_return = avenrun[0] * 100; /* 1 minute average */
  213.         if (long_return > 100)
  214.             long_return = 100;
  215.         return (u_char *) & long_return;
  216.     default:
  217.         DEBUGMSGTL(("snmpd", "unknown sub-id %d in var_hrprocn",
  218.                     vp->magic));
  219.     }
  220.     return NULL;
  221. }
  224.         /*********************
  225.  *
  226.  *  Internal implementation functions
  227.  *
  228.  *********************/
  230. void
  231. Init_HR_Proc(void)
  232. {
  233. #ifdef solaris2
  234.     hrtime_t  current_time;
  235. #endif
  236.     HRP_index = 0;
  237. #ifdef solaris2
  238.     current_time = gethrtime();
  239.     if (current_time > update_time + 2000000000) { /* two seconds */
  240.         kstat_CPU();
  241.         update_time = gethrtime();
  242.     }
  243. #endif
  244. }
  246. int
  247. Get_Next_HR_Proc(void)
  248. {
  249.     if (HRP_index < HRP_max_index)
  250.         return (HRDEV_PROC << HRDEV_TYPE_SHIFT) + HRP_index++;
  251.     else
  252.         return -1;
  253. }
  255. const char     *
  256. describe_proc(int idx)
  257. {
  258. #ifdef _SC_CPU_VERSION
  259.     int             result;
  261.     result = sysconf(_SC_CPU_VERSION);
  262.     switch (result) {
  263.     case CPU_HP_MC68020:
  264.         return (" Motorola MC68020 ");
  265.     case CPU_HP_MC68030:
  266.         return (" Motorola MC68030 ");
  267.     case CPU_HP_MC68040:
  268.         return (" Motorola MC68040 ");
  269.     case CPU_PA_RISC1_0:
  270.         return (" HP PA-RISC 1.0 ");
  271.     case CPU_PA_RISC1_1:
  272.         return (" HP PA-RISC 1.1 ");
  273.     case CPU_PA_RISC1_2:
  274.         return (" HP PA-RISC 1.2 ");
  275.     case CPU_PA_RISC2_0:
  276.         return (" HP PA-RISC 2.0 ");
  277.     default:
  278.         return ("An electronic chip with an HP label");
  280.     }
  281. #elif linux
  282.     return (proc_descriptions[idx & HRDEV_TYPE_MASK]);
  283. #elif solaris2
  284.     int cidx = idx & HRDEV_TYPE_MASK;
  285.     snprintf(proc_description,sizeof(proc_description)-1, 
  286.            "CPU %d Sun %d MHz %s with %s FPU %s",
  287.             cpu[cidx].id,cpu[cidx].clock_MHz,cpu[cidx].cpu_type,cpu[cidx].fpu_type,cpu[cidx].state);
  288.     return proc_description;
  289. #else
  290.     return ("An electronic chip that makes the computer work.");
  291. #endif
  292. }
  294. #ifdef linux
  295. void detect_hrproc(void)
  296. {
  297.     int i;
  298.     char tmpbuf[BUFSIZ], *cp;
  299.     FILE *fp;
  301.     /*
  302.      * Clear the buffers...
  303.      */
  304.     for ( i=0 ; i<MAX_NUM_HRPROC; i++ ) {
  305.         memset( proc_descriptions[i], '', BUFSIZ);
  306.     }
  308.     /*
  309.      * ... and try to interpret the CPU information
  310.      */
  311.     fp = fopen("/proc/cpuinfo", "r");
  312.     if (!fp) {
  313.         sprintf( proc_descriptions[0],
  314.                  "An electronic chip that makes the computer work.");
  315.         return;
  316.     }
  318.     i = 0;
  319.     while (fgets(tmpbuf, BUFSIZ, fp)) {
  320.         if ( !strncmp( tmpbuf, "vendor_id", 9)) {
  321.     /* Stomp on trailing newline... */
  322.             cp = &tmpbuf[strlen(tmpbuf)-1];
  323.     *cp = 0;
  324.     /* ... and then extract the value */
  325.             cp = index( tmpbuf, ':');
  326.     cp++;
  327.     while ( cp && isspace(*cp))
  328.         cp++;
  329.             snprintf( proc_descriptions[i], BUFSIZ, "%s", cp);
  330.         }
  331.         if ( !strncmp( tmpbuf, "model name", 10)) {
  332.     /* Stomp on trailing newline... */
  333.             cp = &tmpbuf[strlen(tmpbuf)-1];
  334.     *cp = 0;
  335.     /* ... and then extract the value */
  336.             cp = index( tmpbuf, ':');
  337.     cp++;
  338.     while ( cp && isspace(*cp))
  339.         cp++;
  340.             strncat( proc_descriptions[i], ": ",
  341.                      BUFSIZ-strlen(proc_descriptions[i]));
  342.             strncat( proc_descriptions[i], cp,
  343.                      BUFSIZ-strlen(proc_descriptions[i]));
  344.             i++;
  345.             if (i >= MAX_NUM_HRPROC) {
  346.                 i--;
  347.                 break;
  348.             }
  349.         }
  350.     }
  351.     HRP_max_index = i;
  352.     fclose(fp);
  353.     return;
  354. }
  355. #endif /* linux */
  357. #ifdef solaris2
  358. void kstat_CPU(void)
  359. {
  360. /* this routine asks the OS for the number of CPU's and uses that value
  361.  * to set HRP_max_index for later use.  Then it asks the OS for
  362.  * specific details of each CPU.  In Solaris, you cannot trust the 
  363.  * first CPU to be 0 or for CPU 0 to even exist, hence there is a 
  364.  * CPU id, state, cpu type, fpu type, state_begin (what does this do??)
  365.  * and CPU speed.  Results are stuffed into the cpu array (see above).
  366.  *
  367.  * In keeping with the spirit of the RFC, the number and index of CPU's
  368.  * is considered to be constant.  Hence, if you start yanking or adding
  369.  * CPU modules eg. on a V880, you will need to start and stop the daemon.
  370.  */
  371.     int i_cpu = -1;
  372.     int i,old_ncpus;
  373.     kstat_ctl_t *kc;
  374.     kstat_t *ksp;
  375.     kstat_named_t *ks_data;
  376.     old_ncpus = ncpus;
  377.     for (i = 0; i < ncpus; i++) {
  378.         strncpy(cpu[i].state,"missing",sizeof(cpu[i].state));
  379.         cpu[i].state[sizeof(cpu[i].state)-1]=''; /* null terminate */
  380.         cpu[i].id = 999999;
  381.         cpu[i].clock_MHz = 999999;
  382.         strncpy(cpu[i].cpu_type,"missing",sizeof(cpu[i].cpu_type));
  383.         cpu[i].state[sizeof(cpu[i].cpu_type)-1]=''; /* null terminate */
  384.         strncpy(cpu[i].fpu_type,"missing",sizeof(cpu[i].fpu_type));
  385.         cpu[i].state[sizeof(cpu[i].cpu_type)-1]=''; /* null terminate */
  386.         }
  387.     getKstat("system_misc", "ncpus", &ncpus);
  388.     if (ncpus > old_ncpus){
  389.         HRP_max_index = ncpus; /* the MIB says to retain indexes */
  390.         }
  391.     if ((old_ncpus != ncpus)&&(old_ncpus != 0)) {
  392.         if (ncpus > old_ncpus){
  393.             snmp_log(LOG_NOTICE,
  394.               "hr_proc: Cool ! Number of CPUs increased, must be hot-pluggable.n");
  395.             }
  396.         else {
  397.             snmp_log(LOG_NOTICE,
  398.                      "hr_proc: Lost at least one CPU, RIP.n");
  399.             }
  400.        }
  401.     if ((kc = kstat_open()) == NULL) {
  402.         DEBUGMSGTL(("hr_proc", "kstat_open failed"));
  403.         }
  404.     else {
  405.         for (ksp = kc->kc_chain; ksp != NULL; ksp = ksp->ks_next)  {
  406.             if (ksp->ks_type == KSTAT_TYPE_NAMED
  407.                &&  strcmp(ksp->ks_module, "cpu_info") == 0
  408.                &&  strcmp(ksp->ks_class, "misc") == 0) {
  409.                    if (kstat_read(kc, ksp, NULL) == -1)  {
  410.                       DEBUGMSGTL(("hr_proc", "kstat_read failed"));
  411.                       }
  412.                    else {
  413.                        i_cpu++;
  414.                        i = 0;
  415.                        cpu[i_cpu].id = ksp->ks_instance;
  416.                        for (ks_data = ksp->ks_data; i < ksp->ks_ndata; i++, ks_data++) {
  417.                            if (strcmp(ks_data->name,"state")==0) {
  418.                                strncpy(cpu[i_cpu].state,ks_data->value.c,sizeof(cpu[i_cpu].state));
  419.                                cpu[i_cpu].state[sizeof(cpu[i_cpu].state)-1]=''; /* null terminate */
  420.                                continue;
  421.                                }
  422.                            else if (strcmp(ks_data->name,"state_begin")==0)   {
  423.                                cpu[i_cpu].state_begin=ks_data->value.i32;
  424.                                continue;
  425.                                }
  426.                            else if (strcmp(ks_data->name,"cpu_type")==0)   {
  427.                                strncpy(cpu[i_cpu].cpu_type,ks_data->value.c,sizeof(cpu[i_cpu].cpu_type));
  428.                                cpu[i_cpu].state[sizeof(cpu[i_cpu].cpu_type)-1]=''; /* null terminate */
  429.                                continue;
  430.                                }
  431.                            else if (strcmp(ks_data->name,"fpu_type")==0)   {
  432.                                strncpy(cpu[i_cpu].fpu_type,ks_data->value.c,sizeof(cpu[i_cpu].fpu_type));
  433.                                cpu[i_cpu].state[sizeof(cpu[i_cpu].fpu_type)-1]=''; /* null terminate */
  434.                                continue;
  435.                                }
  436.                            else if (strcmp(ks_data->name,"clock_MHz")==0)   {
  437.                                cpu[i_cpu].clock_MHz=ks_data->value.i32;
  438.                                continue;
  439.                                }
  440.                            else    {
  441.                                    DEBUGMSGTL(("hr_proc","kstat unexpected cpu parameter"));
  442.                        }
  443.                    }
  444.                }
  445.            }
  446.         }
  447.     }
  448.     kstat_close(kc);
  449. }
  450. int
  451. proc_status(int idx)
  452. {
  453.     /*
  454.      * hrDeviceStatus OBJECT-TYPE
  455.      * SYNTAX     INTEGER {
  456.      * unknown(1), running(2), warning(3), testing(4), down(5)
  457.      * }
  458.      */
  459.     int cidx = idx & HRDEV_TYPE_MASK;
  460.     if (strcmp(cpu[cidx].state,"on-line")==0) {
  461.         return 2;                   /* running */
  462.          }
  463.     else if (strcmp(cpu[cidx].state,"off-line")==0) {
  464.         return 5;                   /* down */
  465.          }
  466.     else if (strcmp(cpu[cidx].state,"missing")==0) {
  467.         return 3;                   /* warning, went missing, see above */
  468.          }
  469.     else if (strcmp(cpu[cidx].state,"testing")==0) {
  470.         return 4;                   /* somebody must be testing code up above */
  471.          }
  472.     else {
  473.         return 1;                   /* unknown */
  474.          }
  475. }
  476. #endif /* solaris2 */