sigar-test 0.7.3.1

data/include/sigar_private.h

@@ -0,0 +1,429 @@
+/*
+ * Copyright (c) 2004-2008 Hyperic, Inc.
+ * Copyright (c) 2009 SpringSource, Inc.
+ * Copyright (c) 2009-2010 VMware, 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_PRIVATE_DOT_H
+#define SIGAR_PRIVATE_DOT_H
+
+#include "sigar_log.h"
+#include "sigar_ptql.h"
+
+#include <stdlib.h>
+#include <string.h>
+#include <ctype.h>
+
+#ifndef WIN32
+#include <unistd.h>
+#include <stddef.h>
+#ifndef DARWIN
+#include <strings.h>
+#endif
+#endif
+
+#ifdef DMALLOC
+#define _MEMORY_H /* exclude memory.h on solaris */
+#define DMALLOC_FUNC_CHECK
+#include <dmalloc.h>
+#endif
+
+/* common to all os sigar_t's */
+/* XXX: this is ugly; but don't want the same stuffs
+ * duplicated on 4 platforms and am too lazy to change
+ * sigar_t to the way it was originally where sigar_t was
+ * common and contained a sigar_os_t.
+ * feel free trav ;-)
+ */
+#define SIGAR_T_BASE \
+   int cpu_list_cores; \
+   int log_level; \
+   void *log_data; \
+   sigar_log_impl_t log_impl; \
+   void *ptql_re_data; \
+   sigar_ptql_re_impl_t ptql_re_impl; \
+   unsigned int ncpu; \
+   unsigned long version; \
+   unsigned long boot_time; \
+   int ticks; \
+   sigar_pid_t pid; \
+   char errbuf[256]; \
+   char *ifconf_buf; \
+   int ifconf_len; \
+   char *self_path; \
+   sigar_proc_list_t *pids; \
+   sigar_cache_t *fsdev; \
+   sigar_cache_t *proc_cpu; \
+   sigar_cache_t *net_listen; \
+   sigar_cache_t *net_services_tcp; \
+   sigar_cache_t *net_services_udp;\
+   sigar_cache_t *proc_io
+
+#if defined(WIN32)
+#   define SIGAR_INLINE __inline
+#elif defined(__GNUC__)
+#   define SIGAR_INLINE inline
+#else
+#   define SIGAR_INLINE
+#endif
+
+#ifdef DMALLOC
+/* linux has its own strdup macro, make sure we use dmalloc's */
+#define sigar_strdup(s) \
+    dmalloc_strndup(__FILE__, __LINE__, (s), -1, 0)
+#else
+#  ifdef WIN32
+#    define sigar_strdup(s) _strdup(s)
+#  else
+#    define sigar_strdup(s) strdup(s)
+#  endif
+#endif
+
+#define SIGAR_ZERO(s) \
+    memset(s, '\0', sizeof(*(s)))
+
+#define SIGAR_STRNCPY(dest, src, len) \
+    strncpy(dest, src, len); \
+    dest[len-1] = '\0'
+
+/* we use fixed size buffers pretty much everywhere */
+/* this is strncpy + ensured \0 terminator */
+#define SIGAR_SSTRCPY(dest, src) \
+    SIGAR_STRNCPY(dest, src, sizeof(dest))
+
+#ifndef strEQ
+#define strEQ(s1, s2) (strcmp(s1, s2) == 0)
+#endif
+
+#ifndef strnEQ
+#define strnEQ(s1, s2, n) (strncmp(s1, s2, n) == 0)
+#endif
+
+#ifdef WIN32
+#define strcasecmp stricmp
+#define strncasecmp strnicmp
+#endif
+
+#ifndef strcaseEQ
+#define strcaseEQ(s1, s2) (strcasecmp(s1, s2) == 0)
+#endif
+
+#ifndef strncaseEQ
+#define strncaseEQ(s1, s2, n) (strncasecmp(s1, s2, n) == 0)
+#endif
+
+#ifdef offsetof
+#define sigar_offsetof offsetof
+#else
+#define sigar_offsetof(type, field) ((size_t)(&((type *)0)->field))
+#endif
+
+#define SIGAR_MSEC 1000L
+#define SIGAR_USEC 1000000L
+#define SIGAR_NSEC 1000000000L
+
+#define SIGAR_SEC2NANO(s) \
+    ((sigar_uint64_t)(s) * (sigar_uint64_t)SIGAR_NSEC)
+
+/* cpu ticks to milliseconds */
+#define SIGAR_TICK2MSEC(s) \
+   ((sigar_uint64_t)(s) * ((sigar_uint64_t)SIGAR_MSEC / (double)sigar->ticks))
+
+#define SIGAR_TICK2NSEC(s) \
+   ((sigar_uint64_t)(s) * ((sigar_uint64_t)SIGAR_NSEC / (double)sigar->ticks))
+
+/* nanoseconds to milliseconds */
+#define SIGAR_NSEC2MSEC(s) \
+   ((sigar_uint64_t)(s) / ((sigar_uint64_t)1000000L))
+
+#define IFTYPE_LO  2
+#define IFTYPE_ETH 3
+
+#define SIGAR_LAST_PROC_EXPIRE 2
+
+#define SIGAR_BUFFER_EXPIRE 1000
+
+#define SIGAR_FS_MAX 10
+
+#define SIGAR_CPU_INFO_MAX 4
+
+#define SIGAR_CPU_LIST_MAX 4
+
+#define SIGAR_PROC_LIST_MAX 256
+
+#define SIGAR_PROC_ARGS_MAX 12
+
+#define SIGAR_NET_ROUTE_LIST_MAX 6
+
+#define SIGAR_NET_IFLIST_MAX 20
+
+#define SIGAR_NET_CONNLIST_MAX 20
+
+#define SIGAR_ARP_LIST_MAX 12
+
+#define SIGAR_WHO_LIST_MAX 12
+
+int sigar_os_open(sigar_t **sigar);
+
+int sigar_os_close(sigar_t *sigar);
+
+char *sigar_os_error_string(sigar_t *sigar, int err);
+
+char *sigar_strerror_get(int err, char *errbuf, int buflen);
+
+void sigar_strerror_set(sigar_t *sigar, char *msg);
+
+void sigar_strerror_printf(sigar_t *sigar, const char *format, ...);
+
+int sigar_sys_info_get_uname(sigar_sys_info_t *sysinfo);
+
+int sigar_os_sys_info_get(sigar_t *sigar, sigar_sys_info_t *sysinfo);
+
+int sigar_os_proc_list_get(sigar_t *sigar,
+                           sigar_proc_list_t *proclist);
+
+int sigar_proc_list_create(sigar_proc_list_t *proclist);
+
+int sigar_proc_list_grow(sigar_proc_list_t *proclist);
+
+#define SIGAR_PROC_LIST_GROW(proclist) \
+    if (proclist->number >= proclist->size) { \
+        sigar_proc_list_grow(proclist); \
+    }
+
+int sigar_proc_args_create(sigar_proc_args_t *proclist);
+
+int sigar_proc_args_grow(sigar_proc_args_t *procargs);
+
+#define SIGAR_PROC_ARGS_GROW(procargs) \
+    if (procargs->number >= procargs->size) { \
+        sigar_proc_args_grow(procargs); \
+    }
+
+int sigar_os_proc_args_get(sigar_t *sigar, sigar_pid_t pid,
+                           sigar_proc_args_t *procargs);
+
+int sigar_file_system_list_create(sigar_file_system_list_t *fslist);
+
+int sigar_file_system_list_grow(sigar_file_system_list_t *fslist);
+
+#define SIGAR_FILE_SYSTEM_LIST_GROW(fslist) \
+    if (fslist->number >= fslist->size) { \
+        sigar_file_system_list_grow(fslist); \
+    }
+
+int sigar_os_fs_type_get(sigar_file_system_t *fsp);
+
+/* os plugins that set fsp->type call fs_type_get directly */
+#define sigar_fs_type_init(fsp) \
+   fsp->type = SIGAR_FSTYPE_UNKNOWN; \
+   sigar_fs_type_get(fsp)
+
+void sigar_fs_type_get(sigar_file_system_t *fsp);
+
+int sigar_cpu_info_list_create(sigar_cpu_info_list_t *cpu_infos);
+
+int sigar_cpu_info_list_grow(sigar_cpu_info_list_t *cpu_infos);
+
+#define SIGAR_CPU_INFO_LIST_GROW(cpu_infos) \
+    if (cpu_infos->number >= cpu_infos->size) { \
+        sigar_cpu_info_list_grow(cpu_infos); \
+    }
+
+int sigar_cpu_list_create(sigar_cpu_list_t *cpulist);
+
+int sigar_cpu_list_grow(sigar_cpu_list_t *cpulist);
+
+#define SIGAR_CPU_LIST_GROW(cpulist) \
+    if (cpulist->number >= cpulist->size) { \
+        sigar_cpu_list_grow(cpulist); \
+    }
+
+int sigar_net_route_list_create(sigar_net_route_list_t *routelist);
+
+int sigar_net_route_list_grow(sigar_net_route_list_t *net_routelist);
+
+#define SIGAR_NET_ROUTE_LIST_GROW(routelist) \
+    if (routelist->number >= routelist->size) { \
+        sigar_net_route_list_grow(routelist); \
+    }
+
+int sigar_net_interface_list_create(sigar_net_interface_list_t *iflist);
+
+int sigar_net_interface_list_grow(sigar_net_interface_list_t *iflist);
+
+#define SIGAR_NET_IFLIST_GROW(iflist) \
+    if (iflist->number >= iflist->size) { \
+        sigar_net_interface_list_grow(iflist); \
+    }
+
+int sigar_net_connection_list_create(sigar_net_connection_list_t *connlist);
+
+int sigar_net_connection_list_grow(sigar_net_connection_list_t *connlist);
+
+#define SIGAR_NET_CONNLIST_GROW(connlist) \
+    if (connlist->number >= connlist->size) { \
+        sigar_net_connection_list_grow(connlist); \
+    }
+
+#define sigar_net_address_set(a, val) \
+    (a).addr.in = val; \
+    (a).family = SIGAR_AF_INET
+
+#define sigar_net_address6_set(a, val) \
+    memcpy(&((a).addr.in6), val, sizeof((a).addr.in6)); \
+    (a).family = SIGAR_AF_INET6
+
+#define SIGAR_IFHWADDRLEN 6
+
+#define sigar_net_address_mac_set(a, val, len) \
+    memcpy(&((a).addr.mac), val, len); \
+    (a).family = SIGAR_AF_LINK
+
+#define sigar_hwaddr_set_null(ifconfig) \
+    SIGAR_ZERO(&ifconfig->hwaddr.addr.mac); \
+    ifconfig->hwaddr.family = SIGAR_AF_LINK
+
+int sigar_net_interface_ipv6_config_get(sigar_t *sigar, const char *name,
+                                        sigar_net_interface_config_t *ifconfig);
+
+#define sigar_net_interface_ipv6_config_init(ifconfig) \
+    ifconfig->address6.family = SIGAR_AF_INET6; \
+    ifconfig->prefix6_length = 0; \
+    ifconfig->scope6 = 0
+
+#define SIGAR_SIN6(s) ((struct sockaddr_in6 *)(s))
+
+#define SIGAR_SIN6_ADDR(s) &SIGAR_SIN6(s)->sin6_addr
+
+#define sigar_net_interface_scope6_set(ifconfig, addr) \
+    if (IN6_IS_ADDR_LINKLOCAL(addr)) \
+        ifconfig->scope6 = SIGAR_IPV6_ADDR_LINKLOCAL; \
+    else if (IN6_IS_ADDR_SITELOCAL(addr)) \
+        ifconfig->scope6 = SIGAR_IPV6_ADDR_SITELOCAL; \
+    else if (IN6_IS_ADDR_V4COMPAT(addr)) \
+        ifconfig->scope6 = SIGAR_IPV6_ADDR_COMPATv4; \
+    else if (IN6_IS_ADDR_LOOPBACK(addr)) \
+        ifconfig->scope6 = SIGAR_IPV6_ADDR_LOOPBACK; \
+    else \
+        ifconfig->scope6 = SIGAR_IPV6_ADDR_ANY
+
+int sigar_tcp_curr_estab(sigar_t *sigar, sigar_tcp_t *tcp);
+
+int sigar_arp_list_create(sigar_arp_list_t *arplist);
+
+int sigar_arp_list_grow(sigar_arp_list_t *arplist);
+
+#define SIGAR_ARP_LIST_GROW(arplist) \
+    if (arplist->number >= arplist->size) { \
+        sigar_arp_list_grow(arplist); \
+    }
+
+int sigar_who_list_create(sigar_who_list_t *wholist);
+
+int sigar_who_list_grow(sigar_who_list_t *wholist);
+
+#define SIGAR_WHO_LIST_GROW(wholist) \
+    if (wholist->number >= wholist->size) { \
+        sigar_who_list_grow(wholist); \
+    }
+
+int sigar_user_id_get(sigar_t *sigar, const char *name, int *uid);
+
+int sigar_user_name_get(sigar_t *sigar, int uid, char *buf, int buflen);
+
+int sigar_group_name_get(sigar_t *sigar, int gid, char *buf, int buflen);
+
+#define SIGAR_PROC_ENV_KEY_LOOKUP() \
+    if ((procenv->type == SIGAR_PROC_ENV_KEY) && \
+        (pid == sigar->pid)) \
+    { \
+        char *value = getenv(procenv->key); \
+        if (value != NULL) { \
+            procenv->env_getter(procenv->data, \
+                                procenv->key, \
+                                procenv->klen, \
+                                value, strlen(value)); \
+        } \
+        return SIGAR_OK; \
+    }
+
+#define SIGAR_DISK_STATS_INIT(disk) \
+    (disk)->reads = (disk)->writes = \
+    (disk)->read_bytes = (disk)->write_bytes = \
+    (disk)->rtime = (disk)->wtime = (disk)->qtime = (disk)->time = \
+    (disk)->queue = (disk)->service_time = SIGAR_FIELD_NOTIMPL; \
+    (disk)->snaptime = 0
+
+/* key used for filesystem (/) -> device (/dev/hda1) mapping */
+/* and disk_usage cache for service_time */
+#define SIGAR_FSDEV_ID(sb) \
+    (S_ISBLK((sb).st_mode) ? (sb).st_rdev : ((sb).st_ino + (sb).st_dev))
+
+#if defined(WIN32) || defined(NETWARE)
+int sigar_get_iftype(const char *name, int *type, int *inst);
+#endif
+
+#define SIGAR_NIC_LOOPBACK "Local Loopback"
+#define SIGAR_NIC_UNSPEC   "UNSPEC"
+#define SIGAR_NIC_SLIP     "Serial Line IP"
+#define SIGAR_NIC_CSLIP    "VJ Serial Line IP"
+#define SIGAR_NIC_SLIP6    "6-bit Serial Line IP"
+#define SIGAR_NIC_CSLIP6   "VJ 6-bit Serial Line IP"
+#define SIGAR_NIC_ADAPTIVE "Adaptive Serial Line IP"
+#define SIGAR_NIC_ETHERNET "Ethernet"
+#define SIGAR_NIC_ASH      "Ash"
+#define SIGAR_NIC_FDDI     "Fiber Distributed Data Interface"
+#define SIGAR_NIC_HIPPI    "HIPPI"
+#define SIGAR_NIC_AX25     "AMPR AX.25"
+#define SIGAR_NIC_ROSE     "AMPR ROSE"
+#define SIGAR_NIC_NETROM   "AMPR NET/ROM"
+#define SIGAR_NIC_X25      "generic X.25"
+#define SIGAR_NIC_TUNNEL   "IPIP Tunnel"
+#define SIGAR_NIC_PPP      "Point-to-Point Protocol"
+#define SIGAR_NIC_HDLC     "(Cisco)-HDLC"
+#define SIGAR_NIC_LAPB     "LAPB"
+#define SIGAR_NIC_ARCNET   "ARCnet"
+#define SIGAR_NIC_DLCI     "Frame Relay DLCI"
+#define SIGAR_NIC_FRAD     "Frame Relay Access Device"
+#define SIGAR_NIC_SIT      "IPv6-in-IPv4"
+#define SIGAR_NIC_IRDA     "IrLAP"
+#define SIGAR_NIC_EC       "Econet"
+#define PID_CACHE_CLEANUP_PERIOD 1000*60*10 /* 10 minutes */
+#define PID_CACHE_ENTRY_EXPIRE_PERIOD 1000*60*20 /* 20 minutes */
+#ifndef WIN32
+#include <netdb.h>
+#endif
+
+#define PROC_PID_CPU_CACHE 1
+#define PROC_PID_IO_CACHE 2
+
+#define SIGAR_HOSTENT_LEN 1024
+#if defined(_AIX)
+#define SIGAR_HAS_HOSTENT_DATA
+#endif
+
+typedef struct {
+    char buffer[SIGAR_HOSTENT_LEN];
+    int error;
+#ifndef WIN32
+    struct hostent hs;
+#endif
+#ifdef SIGAR_HAS_HOSTENT_DATA
+    struct hostent_data hd;
+#endif
+} sigar_hostent_t;
+
+#endif

data/include/sigar_ptql.h

@@ -0,0 +1,53 @@
+/*
+ * Copyright (c) 2006-2007 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_PTQL_H
+#define SIGAR_PTQL_H
+
+#define SIGAR_PTQL_MALFORMED_QUERY -1
+
+typedef struct sigar_ptql_query_t sigar_ptql_query_t;
+
+#define SIGAR_PTQL_ERRMSG_SIZE 1024
+
+typedef struct {
+    char message[SIGAR_PTQL_ERRMSG_SIZE];
+} sigar_ptql_error_t;
+
+typedef int (*sigar_ptql_re_impl_t)(void *, char *, char *);
+
+SIGAR_DECLARE(void) sigar_ptql_re_impl_set(sigar_t *sigar, void *data,
+                                           sigar_ptql_re_impl_t impl);
+
+SIGAR_DECLARE(int) sigar_ptql_query_create(sigar_ptql_query_t **query,
+                                           char *ptql,
+                                           sigar_ptql_error_t *error);
+
+SIGAR_DECLARE(int) sigar_ptql_query_match(sigar_t *sigar,
+                                          sigar_ptql_query_t *query,
+                                          sigar_pid_t pid);
+
+SIGAR_DECLARE(int) sigar_ptql_query_destroy(sigar_ptql_query_t *query);
+
+SIGAR_DECLARE(int) sigar_ptql_query_find_process(sigar_t *sigar,
+                                                 sigar_ptql_query_t *query,
+                                                 sigar_pid_t *pid);
+
+SIGAR_DECLARE(int) sigar_ptql_query_find(sigar_t *sigar,
+                                         sigar_ptql_query_t *query,
+                                         sigar_proc_list_t *proclist);
+
+#endif /*SIGAR_PTQL_H*/

data/include/sigar_util.h

@@ -0,0 +1,197 @@
+/*
+ * Copyright (c) 2004-2008 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.
+ */
+
+#ifndef SIGAR_UTIL_H
+#define SIGAR_UTIL_H
+
+/* most of this is crap for dealing with linux /proc */
+#define UITOA_BUFFER_SIZE \
+    (sizeof(int) * 3 + 1)
+
+#define SSTRLEN(s) \
+    (sizeof(s)-1)
+
+#define sigar_strtoul(ptr) \
+    strtoul(ptr, &ptr, 10)
+
+#define sigar_strtoull(ptr) \
+    strtoull(ptr, &ptr, 10)
+
+#define sigar_isspace(c) \
+    (isspace(((unsigned char)(c))))
+
+#define sigar_isdigit(c) \
+    (isdigit(((unsigned char)(c))))
+
+#define sigar_isalpha(c) \
+    (isalpha(((unsigned char)(c))))
+
+#define sigar_isupper(c) \
+    (isupper(((unsigned char)(c))))
+
+#define sigar_tolower(c) \
+    (tolower(((unsigned char)(c))))
+
+#ifdef WIN32
+#define sigar_fileno _fileno
+#define sigar_isatty _isatty
+#define sigar_write  _write
+#else
+#define sigar_fileno fileno
+#define sigar_isatty isatty
+#define sigar_write  write
+#endif
+
+#ifndef PROC_FS_ROOT
+#define PROC_FS_ROOT "/proc/"
+#endif
+
+#ifndef PROCP_FS_ROOT
+#define PROCP_FS_ROOT "/proc/"
+#endif
+
+sigar_int64_t sigar_time_now_millis(void);
+
+char *sigar_uitoa(char *buf, unsigned int n, int *len);
+
+int sigar_inet_ntoa(sigar_t *sigar,
+                    sigar_uint32_t address,
+                    char *addr_str);
+
+struct hostent *sigar_gethostbyname(const char *name,
+                                    sigar_hostent_t *data);
+
+SIGAR_INLINE char *sigar_skip_line(char *buffer, int buflen);
+
+SIGAR_INLINE char *sigar_skip_token(char *p);
+
+SIGAR_INLINE char *sigar_skip_multiple_token(char *p, int count);
+
+char *sigar_getword(char **line, char stop);
+
+char *sigar_strcasestr(const char *s1, const char *s2);
+
+int sigar_file2str(const char *fname, char *buffer, int buflen);
+
+int sigar_proc_file2str(char *buffer, int buflen,
+                        sigar_pid_t pid,
+                        const char *fname,
+                        int fname_len);
+
+#define SIGAR_PROC_FILE2STR(buffer, pid, fname) \
+    sigar_proc_file2str(buffer, sizeof(buffer), \
+                        pid, fname, SSTRLEN(fname))
+
+#define SIGAR_PROC_FILENAME(buffer, pid, fname) \
+    sigar_proc_filename(buffer, sizeof(buffer), \
+                        pid, fname, SSTRLEN(fname))
+
+#define SIGAR_SKIP_SPACE(ptr) \
+    while (sigar_isspace(*ptr)) ++ptr
+
+char *sigar_proc_filename(char *buffer, int buflen,
+                          sigar_pid_t pid,
+                          const char *fname, int fname_len);
+
+int sigar_proc_list_procfs_get(sigar_t *sigar,
+                               sigar_proc_list_t *proclist);
+
+int sigar_proc_fd_count(sigar_t *sigar, sigar_pid_t pid,
+                        sigar_uint64_t *total);
+
+/* linux + freebsd */
+int sigar_procfs_args_get(sigar_t *sigar, sigar_pid_t pid,
+                          sigar_proc_args_t *procargs);
+
+int sigar_mem_calc_ram(sigar_t *sigar, sigar_mem_t *mem);
+
+int sigar_statvfs(sigar_t *sigar,
+                  const char *dirname,
+                  sigar_file_system_usage_t *fsusage);
+
+double sigar_file_system_usage_calc_used(sigar_t *sigar,
+                                         sigar_file_system_usage_t *fs);
+
+#define SIGAR_DEV_PREFIX "/dev/"
+
+#define SIGAR_NAME_IS_DEV(dev) \
+    strnEQ(dev, SIGAR_DEV_PREFIX, SSTRLEN(SIGAR_DEV_PREFIX))
+
+typedef struct {
+    char name[256];
+    int is_partition;
+    sigar_disk_usage_t disk;
+} sigar_iodev_t;
+
+sigar_iodev_t *sigar_iodev_get(sigar_t *sigar,
+                               const char *dirname);
+
+int sigar_cpu_core_count(sigar_t *sigar);
+
+/* e.g. VM guest may have 1 virtual ncpu on multicore hosts */
+#define sigar_cpu_socket_count(sigar) \
+    (sigar->ncpu < sigar->lcpu) ? sigar->ncpu : \
+    (sigar->ncpu / sigar->lcpu)
+
+int sigar_cpu_core_rollup(sigar_t *sigar);
+
+void sigar_cpu_model_adjust(sigar_t *sigar, sigar_cpu_info_t *info);
+
+int sigar_cpu_mhz_from_model(char *model);
+
+char *sigar_get_self_path(sigar_t *sigar);
+
+#if defined(__sun) || defined(__FreeBSD__)
+
+#define SIGAR_HAS_DLINFO_MODULES
+#include <dlfcn.h>
+#include <link.h>
+
+int sigar_dlinfo_modules(sigar_t *sigar, sigar_proc_modules_t *procmods);
+#endif
+
+typedef struct sigar_cache_entry_t sigar_cache_entry_t;
+
+struct sigar_cache_entry_t {
+    sigar_cache_entry_t *next;
+    sigar_uint64_t id;
+    void *value;
+    sigar_uint64_t last_access_time;
+};
+
+typedef struct {
+    sigar_cache_entry_t **entries;
+    unsigned int count, size;
+    void (*free_value)(void *ptr);
+    sigar_uint64_t entry_expire_period;
+    sigar_uint64_t cleanup_period_millis;
+    sigar_uint64_t last_cleanup_time;
+} sigar_cache_t;
+
+sigar_cache_t *sigar_cache_new(int size);
+sigar_cache_t *sigar_expired_cache_new(int size, sigar_uint64_t cleanup_period_millis, sigar_uint64_t entry_expire_period);
+void sigar_cache_dump(sigar_cache_t *table);
+
+sigar_cache_entry_t *sigar_cache_get(sigar_cache_t *table,
+                                     sigar_uint64_t key);
+
+sigar_cache_entry_t *sigar_cache_find(sigar_cache_t *table,
+                                      sigar_uint64_t key);
+
+void sigar_cache_destroy(sigar_cache_t *table);
+
+#endif /* SIGAR_UTIL_H */