sigar-test 0.7.3.1

data/src/os/linux/sigar_os.h

@@ -0,0 +1,82 @@
+/*
+ * Copyright (c) 2004-2008 Hyperic, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef SIGAR_OS_H
+#define SIGAR_OS_H
+
+#include <assert.h>
+
+#include <stdlib.h>
+#include <unistd.h>
+#include <fcntl.h>
+#include <ctype.h>
+#include <time.h>
+
+#include <netinet/in.h>
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <arpa/inet.h>
+
+typedef struct {
+    sigar_pid_t pid;
+    time_t mtime;
+    sigar_uint64_t vsize;
+    sigar_uint64_t rss;
+    sigar_uint64_t minor_faults;
+    sigar_uint64_t major_faults;
+    sigar_uint64_t ppid;
+    int tty;
+    int priority;
+    int nice;
+    sigar_uint64_t start_time;
+    sigar_uint64_t utime;
+    sigar_uint64_t stime;
+    char name[SIGAR_PROC_NAME_LEN];
+    char state;
+    int processor;
+} linux_proc_stat_t;
+
+typedef enum {
+    IOSTAT_NONE,
+    IOSTAT_PARTITIONS, /* 2.4 */
+    IOSTAT_DISKSTATS, /* 2.6 */
+    IOSTAT_SYS /* 2.6 */
+} linux_iostat_e;
+
+struct sigar_t {
+    SIGAR_T_BASE;
+    int pagesize;
+    int ram;
+    int proc_signal_offset;
+    linux_proc_stat_t last_proc_stat;
+    int lcpu;
+    linux_iostat_e iostat;
+    char *proc_net;
+    /* Native POSIX Thread Library 2.6+ kernel */
+    int has_nptl;
+};
+
+#define HAVE_STRERROR_R
+#ifndef __USE_XOPEN2K
+/* use gnu version of strerror_r */
+#define HAVE_STRERROR_R_GLIBC
+#endif
+#define HAVE_READDIR_R
+#define HAVE_GETPWNAM_R
+#define HAVE_GETPWUID_R
+#define HAVE_GETGRGID_R
+
+#endif /* SIGAR_OS_H */

data/src/os/solaris/get_mib2.c

@@ -0,0 +1,321 @@
+/*
+ * get_mib2() -- get MIB2 information from Solaris 2.[3-7] kernel
+ *
+ * V. Abell <abe@cc.purdue.edu>
+ * Purdue University Computing Center
+ */
+
+
+/*
+ * Copyright 1995 Purdue Research Foundation, West Lafayette, Indiana
+ * 47907.  All rights reserved.
+ *
+ * Written by Victor A. Abell <abe@cc.purdue.edu>
+ *
+ * This software is not subject to any license of the American Telephone
+ * and Telegraph Company or the Regents of the University of California.
+ *
+ * Permission is granted to anyone to use this software for any purpose on
+ * any computer system, and to alter it and redistribute it freely, subject
+ * to the following restrictions:
+ *
+ * 1. Neither Victor A  Abell nor Purdue University are responsible for
+ *    any consequences of the use of this software.
+ *
+ * 2. The origin of this software must not be misrepresented, either by
+ *    explicit claim or by omission.  Credit to Victor A. Abell and Purdue
+ *    University must appear in documentation and sources.
+ *
+ * 3. Altered versions must be plainly marked as such, and must not be
+ *    misrepresented as being the original software.
+ *
+ * 4. This notice may not be removed or altered.
+ */
+
+/*
+ * Altered for sigar:
+ * - remove static stuff to make thread-safe by Doug MacEachern (3/11/05)
+ */
+
+#if 0 /*ndef lint -Wall -Werror*/ 
+static char copyright[] =
+"@(#) Copyright 1995 Purdue Research Foundation.\nAll rights reserved.\n";
+#endif
+
+#include "get_mib2.h"
+
+#include <errno.h>
+#include <fcntl.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+
+#ifdef DMALLOC
+#include <dmalloc.h>
+#endif
+
+/*
+ * close_mib2() - close MIB2 access
+ *
+ * return:
+ *
+ *	exit = GET_MIB2_OK if close succeeded
+ *	       GET_MIB2_* is the error code.
+ */
+
+int
+close_mib2(solaris_mib2_t *mib2)
+{
+    if (mib2->sd < 0) {
+        (void) strcpy(mib2->errmsg, "close_mib2: socket not open");
+        return(GET_MIB2_ERR_NOTOPEN);
+    }
+    if (close(mib2->sd)) {
+        (void) sprintf(mib2->errmsg, "close_mib2: %s", strerror(errno));
+        return(GET_MIB2_ERR_CLOSE);
+    }
+    mib2->sd = -1;
+    if (mib2->db_len && mib2->db) {
+        mib2->db_len = 0;
+        free((void *)mib2->db);
+        mib2->db = NULL;
+    }
+    if (mib2->smb_len && mib2->smb) {
+        mib2->smb_len = 0;
+        free((void *)mib2->smb);
+        mib2->smb = NULL;
+    }
+    return(GET_MIB2_OK);
+}
+
+
+/*
+ * get_mib2() - get MIB2 data
+ *
+ * return:
+ *
+ *	exit = GET_MIB2_OK if get succeeded, and:
+ *			*opt = opthdr structure address
+ *			*data = data buffer address
+ *			*datalen = size of data buffer
+ *	       GET_MIB2_* is the error code for failure.
+ */
+
+int
+get_mib2(solaris_mib2_t *mib2,
+         struct opthdr **opt,
+         char **data,
+         int *datalen)
+{
+    struct strbuf d;		/* streams data buffer */
+    int err;			/* error code */
+    int f;				/* flags */
+    int rc;				/* reply code */
+
+    /*
+     * If MIB2 access isn't open, open it and issue the preliminary stream
+     * messages.
+     */
+    if (mib2->sd < 0) {
+	/*
+	 * Open access.  Return on error.
+	 */
+        if ((err = open_mib2(mib2))) {
+            return(err);
+        }
+	/*
+	 * Set up message request and option.
+	 */
+        mib2->req = (struct T_optmgmt_req *)mib2->smb;
+        mib2->op = (struct opthdr *)&mib2->smb[sizeof(struct T_optmgmt_req)];
+        mib2->req->PRIM_type = T_OPTMGMT_REQ;
+        mib2->req->OPT_offset = sizeof(struct T_optmgmt_req);
+        mib2->req->OPT_length = sizeof(struct opthdr);
+
+#if	defined(MI_T_CURRENT)
+        mib2->req->MGMT_flags = MI_T_CURRENT;
+#else	/* !defined(MI_T_CURRENT) */
+# if	defined(T_CURRENT)
+        mib2->req->MGMT_flags = T_CURRENT;
+# else	/* !defined(T_CURRENT) */
+#error	"Neither MI_T_CURRENT nor T_CURRENT are defined."
+# endif	/* defined(T_CURRENT) */
+#endif	/* defined(MI_T_CURRENT) */
+
+        mib2->op->level = MIB2_IP;
+        mib2->op->name = mib2->op->len = 0;
+        mib2->ctlbuf.buf = mib2->smb;
+        mib2->ctlbuf.len = mib2->req->OPT_offset + mib2->req->OPT_length;
+	/*
+	 * Put the message.
+	 */
+        if (putmsg(mib2->sd, &mib2->ctlbuf, (struct strbuf *)NULL, 0) == -1) {
+            (void) sprintf(mib2->errmsg,
+                           "get_mib2: putmsg request: %s", strerror(errno));
+            return(GET_MIB2_ERR_PUTMSG);
+        }
+	/*
+	 * Set up to process replies.
+	 */
+        mib2->op_ack = (struct T_optmgmt_ack *)mib2->smb;
+        mib2->ctlbuf.maxlen = mib2->smb_len;
+        mib2->err_ack = (struct T_error_ack *)mib2->smb;
+        mib2->op = (struct opthdr *)&mib2->smb[sizeof(struct T_optmgmt_ack)];
+    }
+    /*
+     * Get the next (first) reply message.
+     */
+    f = 0;
+    if ((rc = getmsg(mib2->sd, &mib2->ctlbuf, NULL, &f)) < 0) {
+        (void) sprintf(mib2->errmsg, "get_mib2: getmsg(reply): %s",
+                       strerror(errno));
+        return(GET_MIB2_ERR_GETMSGR);
+    }
+    /*
+     * Check for end of data.
+     */
+    if (rc == 0
+	&&  mib2->ctlbuf.len >= sizeof(struct T_optmgmt_ack)
+	&&  mib2->op_ack->PRIM_type == T_OPTMGMT_ACK
+	&&  mib2->op_ack->MGMT_flags == T_SUCCESS
+	&&  mib2->op->len == 0)
+    {
+        err = close_mib2(mib2);
+        if (err) {
+            return(err);
+        }
+        return(GET_MIB2_EOD);
+    }
+    /*
+     * Check for error.
+     */
+    if (mib2->ctlbuf.len >= sizeof(struct T_error_ack)
+	&&  mib2->err_ack->PRIM_type == T_ERROR_ACK)
+    {
+        (void) sprintf(mib2->errmsg,
+                       "get_mib2: T_ERROR_ACK: len=%d, TLI=%#x, UNIX=%#x",
+                       mib2->ctlbuf.len,
+                       (int)mib2->err_ack->TLI_error,
+                       (int)mib2->err_ack->UNIX_error);
+        return(GET_MIB2_ERR_ACK);
+    }
+    /*
+     * Check for no data.
+     */
+    if (rc != MOREDATA
+	||  mib2->ctlbuf.len < sizeof(struct T_optmgmt_ack)
+	||  mib2->op_ack->PRIM_type != T_OPTMGMT_ACK
+	||  mib2->op_ack->MGMT_flags != T_SUCCESS)
+    {
+        (void) sprintf(mib2->errmsg,
+                       "get_mib2: T_OPTMGMT_ACK: "
+                       "rc=%d len=%d type=%#x flags=%#x",
+                       rc, mib2->ctlbuf.len,
+                       (int)mib2->op_ack->PRIM_type,
+                       (int)mib2->op_ack->MGMT_flags);
+        return(GET_MIB2_ERR_NODATA);
+    }
+    /*
+     * Allocate (or enlarge) the data buffer.
+     */
+    if (mib2->op->len >= mib2->db_len) {
+        mib2->db_len = mib2->op->len;
+        if (mib2->db == NULL) {
+            mib2->db = (char *)malloc(mib2->db_len);
+        }
+        else {
+            mib2->db = (char *)realloc(mib2->db, mib2->db_len);
+        }
+        if (mib2->db == NULL) {
+            (void) sprintf(mib2->errmsg,
+                           "get_mib2: no space for %d byte data buffer",
+                           mib2->db_len);
+            return(GET_MIB2_ERR_NOSPC);
+        }
+    }
+    /*
+     * Get the data part of the message -- the MIB2 part.
+     */
+    d.maxlen = mib2->op->len;
+    d.buf = mib2->db;
+    d.len = 0;
+    f = 0;
+    if ((rc = getmsg(mib2->sd, NULL, &d, &f)) < 0) {
+        (void) sprintf(mib2->errmsg, "get_mib2: getmsg(data): %s",
+                       strerror(errno));
+        return(GET_MIB2_ERR_GETMSGD);
+    }
+    if (rc) {
+        (void) sprintf(mib2->errmsg,
+                       "get_mib2: getmsg(data): rc=%d maxlen=%d len=%d: %s",
+                       rc, d.maxlen, d.len, strerror(errno));
+        return(GET_MIB2_ERR_GETMSGD);
+    }
+    /*
+     * Compose a successful return.
+     */
+    *opt = mib2->op;
+    *data = mib2->db;
+    *datalen = d.len;
+    return(GET_MIB2_OK);
+}
+
+
+/*
+ * open_mib2() - open access to MIB2 data
+ *
+ * return:
+ *
+ *	exit = GET_MIB2_OK if open succeeded
+ *	       GET_MIB2_* is the error code for failure.
+ */
+
+int
+open_mib2(solaris_mib2_t *mib2)
+{
+    /*
+     * It's an error if the stream device is already open.
+     */
+    if (mib2->sd >= 0) {
+        (void) strcpy(mib2->errmsg, "open_mib2: MIB2 access already open");
+        return(GET_MIB2_ERR_OPEN);
+    }
+    /*
+     * Open the ARP stream device, push TCP and UDP on it.
+     */
+    if ((mib2->sd = open(GET_MIB2_ARPDEV, O_RDWR, 0600)) < 0) {
+        (void) sprintf(mib2->errmsg, "open_mib2: %s: %s", GET_MIB2_ARPDEV,
+                       strerror(errno));
+        return(GET_MIB2_ERR_ARPOPEN);
+    }
+    if (ioctl(mib2->sd, I_PUSH, GET_MIB2_TCPSTREAM) == -1) {
+        (void) sprintf(mib2->errmsg, "open_mib2: push %s: %s",
+                       GET_MIB2_TCPSTREAM, strerror(errno));
+        return(GET_MIB2_ERR_TCPPUSH);
+    }
+    if (ioctl(mib2->sd, I_PUSH, GET_MIB2_UDPSTREAM) == -1) {
+        (void) sprintf(mib2->errmsg, "open_mib2: push %s: %s",
+                       GET_MIB2_UDPSTREAM, strerror(errno));
+        return(GET_MIB2_ERR_UDPPUSH);
+    }
+    /*
+     * Allocate a stream message buffer.
+     */
+    mib2->smb_len = sizeof(struct opthdr) + sizeof(struct T_optmgmt_req);
+    if (mib2->smb_len < (sizeof (struct opthdr) + sizeof(struct T_optmgmt_ack))) {
+        mib2->smb_len = sizeof (struct opthdr) + sizeof(struct T_optmgmt_ack);
+    }
+    if (mib2->smb_len < sizeof(struct T_error_ack)) {
+        mib2->smb_len = sizeof(struct T_error_ack);
+    }
+    if ((mib2->smb = (char *)malloc(mib2->smb_len)) == NULL) {
+        (void) strcpy(mib2->errmsg,
+                      "open_mib2: no space for stream message buffer");
+        return(GET_MIB2_ERR_NOSPC);
+    }
+    /*
+     * All is OK.  Return that indication.
+     */
+    return(GET_MIB2_OK);
+}

data/src/os/solaris/get_mib2.h

@@ -0,0 +1,127 @@
+/*
+ * get_mib2.h -- definitions for the get_mib2() function
+ *
+ * V. Abell <abe@cc.purdue.edu>
+ * Purdue University Computing Center
+ */
+
+
+/*
+ * Copyright 1995 Purdue Research Foundation, West Lafayette, Indiana
+ * 47907.  All rights reserved.
+ *
+ * Written by Victor A. Abell <abe@cc.purdue.edu>
+ *
+ * This software is not subject to any license of the American Telephone
+ * and Telegraph Company or the Regents of the University of California.
+ *
+ * Permission is granted to anyone to use this software for any purpose on
+ * any computer system, and to alter it and redistribute it freely, subject
+ * to the following restrictions:
+ *
+ * 1. Neither Victor A  Abell nor Purdue University are responsible for
+ *    any consequences of the use of this software.
+ *
+ * 2. The origin of this software must not be misrepresented, either by
+ *    explicit claim or by omission.  Credit to Victor A. Abell and Purdue
+ *    University must appear in documentation and sources.
+ *
+ * 3. Altered versions must be plainly marked as such, and must not be
+ *    misrepresented as being the original software.
+ *
+ * 4. This notice may not be removed or altered.
+ */
+
+/*
+ * Altered for sigar:
+ * - remove static stuff to make thread-safe by Doug MacEachern (3/11/05)
+ */
+
+#if	!defined(GET_MIB2_H)
+#define	GET_MIB2_H
+
+
+/*
+ * Required header files
+ */
+
+#include <stropts.h>
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <sys/stream.h>
+#include <sys/tihdr.h>
+#include <sys/tiuser.h>
+#include <inet/mib2.h>
+#include <inet/led.h>
+
+
+/*
+ * Miscellaneous definitions
+ */
+
+#define	GET_MIB2_ARPDEV		"/dev/arp"	/* ARP stream devi9ce */
+#define	GET_MIB2_ERRMSGL	1024		/* ErrMsg buffer length */
+#define	GET_MIB2_TCPSTREAM	"tcp"		/* TCP stream name */
+#define	GET_MIB2_UDPSTREAM	"udp"		/* UDP stream name */
+
+
+/*
+ * get_mib2() response codes
+ *
+ * 	-1		End of MIB2 information
+ *	 0		Next MIB2 structure returned
+ *	>0		Error code
+ */
+
+#define	GET_MIB2_EOD		-1	/* end of data */
+#define	GET_MIB2_OK		0	/* function succeeded */
+#define	GET_MIB2_ERR_ACK	1	/* getmsg() ACK error received */
+#define	GET_MIB2_ERR_ARPOPEN	2	/* error opening ARPDEV */
+#define	GET_MIB2_ERR_CLOSE	3	/* MIB2 access close error */
+#define	GET_MIB2_ERR_GETMSGD	4	/* error getting message data */
+#define	GET_MIB2_ERR_GETMSGR	5	/* error getting message reply */
+#define	GET_MIB2_ERR_NODATA	6	/* data expected; not received */
+#define	GET_MIB2_ERR_NOSPC	7	/* no malloc() space */
+#define	GET_MIB2_ERR_NOTOPEN	8	/* MIB2 access not open */
+#define	GET_MIB2_ERR_OPEN	9	/* MIB2 access open error */
+#define	GET_MIB2_ERR_PUTMSG	10	/* error putting request message */
+#define	GET_MIB2_ERR_TCPPUSH	11	/* error pushing TCPSTREAM */
+#define	GET_MIB2_ERR_UDPPUSH	12	/* error pushing UDPSTREAM */
+
+#define	GET_MIB2_ERR_MAX	13	/* maximum error number + 1 */
+
+
+typedef struct {
+    char *db;       /* data buffer */
+    int db_len;     /* data buffer length */
+    char *smb;      /* stream message buffer */
+    size_t smb_len; /* size of Smb[] */
+    int sd;         /* stream device descriptor */
+    char errmsg[GET_MIB2_ERRMSGL];      /* error message buffer */
+    struct T_optmgmt_ack *op_ack;       /* message ACK pointer */ 
+    struct strbuf ctlbuf;               /* streams control buffer */
+    struct T_error_ack *err_ack;        /* message error pointer */
+    struct opthdr *op;                  /* message option pointer */
+    struct T_optmgmt_req *req;          /* message request pointer */
+} solaris_mib2_t;
+
+/*
+ * Function prototypes
+ */
+
+int close_mib2(				/* close acccess to MIB2 information */
+        solaris_mib2_t *mib2 
+	);
+int get_mib2(				/* get MIB2 information */
+        solaris_mib2_t *mib2, 
+	struct opthdr **opt,			/* opthdr pointer return (see
+						 * <sys/socket.h> */
+	char **data,				/* data buffer return address */
+	int *datalen				/* data buffer length return
+						 * address */
+	);
+int open_mib2(				/* open acccess to MIB2 information */
+        solaris_mib2_t *mib2 
+	);
+
+#endif	/* !defined(GET_MIB2_H) */

data/src/os/solaris/kstats.c

@@ -0,0 +1,181 @@
+/*
+ * Copyright (c) 2004-2007 Hyperic, Inc.
+ * Copyright (c) 2009 SpringSource, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "sigar.h"
+#include "sigar_private.h"
+#include "sigar_util.h"
+#include "sigar_os.h"
+
+int sigar_get_kstats(sigar_t *sigar)
+{
+    kstat_ctl_t *kc = sigar->kc;
+    unsigned int i, id, ncpu = sysconf(_SC_NPROCESSORS_CONF);
+    int is_debug = SIGAR_LOG_IS_DEBUG(sigar);
+
+    if (ncpu != sigar->ncpu) {
+        if (!sigar->ks.lcpu) {
+            /* init */
+            sigar->ks.lcpu = ncpu;
+            sigar->ks.cpu = malloc(sizeof(*(sigar->ks.cpu)) * ncpu);
+            sigar->ks.cpu_info = malloc(sizeof(*(sigar->ks.cpu_info)) * ncpu);
+            sigar->ks.cpuid = malloc(sizeof(*(sigar->ks.cpuid)) * ncpu);
+        }
+        else {
+            sigar_log_printf(sigar, SIGAR_LOG_INFO,
+                             "ncpu changed from %d to %d",
+                             sigar->ncpu, ncpu);
+            if (ncpu > sigar->ks.lcpu) {
+                /* one or more cpus have been added */
+                sigar->ks.cpu = realloc(sigar->ks.cpu,
+                                        sizeof(*(sigar->ks.cpu)) * ncpu);
+                sigar->ks.cpu_info = realloc(sigar->ks.cpu_info,
+                                             sizeof(*(sigar->ks.cpu_info)) * ncpu);
+                sigar->ks.cpuid = realloc(sigar->ks.cpuid,
+                                          sizeof(*(sigar->ks.cpuid)) * ncpu);
+                sigar->ks.lcpu = ncpu;
+            }
+            /* else or more cpus have been removed */
+        }
+
+        sigar->ncpu = ncpu;
+
+        /* from man p_online:
+         * ``Processor numbers are integers,
+         *   greater than or equal to 0,
+         *   and are defined by the hardware platform.
+         *   Processor numbers are not necessarily contiguous,
+         *   but "not too sparse."``
+         * so we maintain our own mapping in ks.cpuid[]
+         */
+
+        /* lookup in order, which kstat chain may not be in */
+        for (i=0, id=0; i<ncpu; id++) {
+            kstat_t *cpu_info, *cpu_stat;
+
+            if (!(cpu_info = kstat_lookup(kc, "cpu_info", id, NULL))) {
+                continue;
+            }
+
+            if (!(cpu_stat = kstat_lookup(kc, "cpu_stat", id, NULL))) {
+                /* XXX warn, faulted cpu? */
+            }
+
+            sigar->ks.cpu_info[i] = cpu_info;
+            sigar->ks.cpu[i] = cpu_stat;
+            sigar->ks.cpuid[i] = id;
+
+            if (is_debug) {
+                sigar_log_printf(sigar, SIGAR_LOG_DEBUG,
+                                 "cpu %d id=%d", i, sigar->ks.cpuid[i]);
+            }
+            i++;
+        }
+    }
+        
+    sigar->ks.system   = kstat_lookup(kc, "unix", -1, "system_misc");
+    sigar->ks.syspages = kstat_lookup(kc, "unix", -1, "system_pages");
+    sigar->ks.mempages = kstat_lookup(kc, "bunyip", -1, "mempages");
+
+    return SIGAR_OK;
+}
+
+SIGAR_INLINE kid_t sigar_kstat_update(sigar_t *sigar)
+{
+    kid_t id = kstat_chain_update(sigar->kc);
+
+    switch (id) {
+      case -1:
+        sigar_log_printf(sigar, SIGAR_LOG_ERROR,
+                         "kstat_chain_update error: %s",
+                         sigar_strerror(sigar, errno));
+        break;
+      case 0:
+        /* up-to-date */
+        break;
+      default:
+        sigar_get_kstats(sigar);
+        sigar_log(sigar, SIGAR_LOG_DEBUG,
+                  "kstat chain updated");
+        break;
+    }
+
+    return id;
+}
+
+/*
+ * bincompat is not possible with certain kstat data structures between
+ * solaris 2.6, 2.7, 2.8, etc.  alternative is to use kstat_data_lookup()
+ * which means everytime we want a stat, must do a linear search
+ * of ksp->ks_data.  eek.  so we meet half way and do the search for
+ * each key once per sigar_t instance.  once the initial search has
+ * been done, we have a table of offsets to quickly access the stats via
+ * ksp->ks_data + offset.  this gives us bincompat without the overhead
+ * of many kstat_data_lookup calls.
+ */
+static SIGAR_INLINE int kstat_named_offset(kstat_t *ksp, const char *name)
+{
+    unsigned int i;
+    kstat_named_t *kn;
+
+    for (i=0, kn=ksp->ks_data;
+         i<ksp->ks_ndata;
+         i++, kn++)
+    {
+        if (strEQ(kn->name, name)) {
+            return i;
+        }
+    }
+
+    return -2; /* not found */
+}
+
+static char *kstat_keys_system[] = {
+    "boot_time",
+    "avenrun_1min",
+    "avenrun_5min",
+    "avenrun_15min",
+    NULL
+};
+
+static char *kstat_keys_mempages[] = {
+    "pages_anon",
+    "pages_exec",
+    "pages_vnode",
+    NULL
+};
+
+static char *kstat_keys_syspages[] = {
+    "pagesfree",
+    NULL
+};
+
+static char **kstat_keys[] = {
+    kstat_keys_system,
+    kstat_keys_mempages,
+    kstat_keys_syspages,
+};
+
+void sigar_koffsets_lookup(kstat_t *ksp, int *offsets, int kidx)
+{
+    int i;
+    char **keys = kstat_keys[kidx];
+
+    for (i=0; keys[i]; i++) {
+        offsets[i] = kstat_named_offset(ksp, keys[i]);
+    }
+}
+