sigar 0.7.0

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]);
+    }
+}
+

data/src/os/solaris/procfs.c

@@ -0,0 +1,97 @@
+/*
+ * Copyright (c) 2004, 2006 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.
+ */
+
+#include "sigar.h"
+#include "sigar_private.h"
+#include "sigar_util.h"
+#include "sigar_os.h"
+
+#define my_pread(fd, ptr, type, offset) \
+    (pread(fd, ptr, sizeof(type), offset) == sizeof(type))
+
+int sigar_proc_psinfo_get(sigar_t *sigar, sigar_pid_t pid)
+{
+    int fd, retval = SIGAR_OK;
+    char buffer[BUFSIZ];
+    time_t timenow = time(NULL);
+
+    if (sigar->pinfo == NULL) {
+        sigar->pinfo = malloc(sizeof(*sigar->pinfo));
+    }
+
+    if (sigar->last_pid == pid) {
+        if ((timenow - sigar->last_getprocs) < SIGAR_LAST_PROC_EXPIRE) {
+            return SIGAR_OK;
+        }
+    }
+
+    sigar->last_pid = pid;
+    sigar->last_getprocs = timenow;
+
+    (void)SIGAR_PROC_FILENAME(buffer, pid, "/psinfo");
+
+    if ((fd = open(buffer, O_RDONLY)) < 0) {
+        return ESRCH;
+    }
+
+    if (!my_pread(fd, sigar->pinfo, psinfo_t, 0)) {
+        retval = errno;
+    }
+
+    close(fd);
+
+    return retval;
+}
+
+int sigar_proc_usage_get(sigar_t *sigar, prusage_t *prusage, sigar_pid_t pid)
+{
+    int fd, retval = SIGAR_OK;
+    char buffer[BUFSIZ];
+
+    (void)SIGAR_PROC_FILENAME(buffer, pid, "/usage");
+
+    if ((fd = open(buffer, O_RDONLY)) < 0) {
+        return ESRCH;
+    }
+
+    if (!my_pread(fd, prusage, prusage_t, 0)) {
+        retval = errno;
+    }
+
+    close(fd);
+
+    return retval;
+}
+
+int sigar_proc_status_get(sigar_t *sigar, pstatus_t *pstatus, sigar_pid_t pid)
+{
+    int fd, retval = SIGAR_OK;
+    char buffer[BUFSIZ];
+
+    (void)SIGAR_PROC_FILENAME(buffer, pid, "/status");
+
+    if ((fd = open(buffer, O_RDONLY)) < 0) {
+        return ESRCH;
+    }
+
+    if (!my_pread(fd, pstatus, pstatus_t, 0)) {
+        retval = errno;
+    }
+
+    close(fd);
+
+    return retval;
+}

data/src/os/solaris/sigar_os.h

@@ -0,0 +1,224 @@
+/*
+ * 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.
+ */
+
+#ifndef SIGAR_OS_H
+#define SIGAR_OS_H
+
+#ifndef _POSIX_PTHREAD_SEMANTICS
+#define _POSIX_PTHREAD_SEMANTICS
+#endif
+
+typedef unsigned long long int u_int64_t;
+
+#include <ctype.h>
+#include <assert.h>
+#ifndef DMALLOC
+#include <malloc.h>
+#endif
+#include <unistd.h>
+#include <fcntl.h>
+#include <stdio.h>
+#include <errno.h>
+#include <stdlib.h>
+#include <sys/types.h>
+#include <sys/processor.h>
+#include <sys/sysinfo.h>
+#include <sys/param.h>
+
+#include <kstat.h>
+#include <procfs.h>
+
+#include "get_mib2.h"
+
+/* avoid -Wall warning since solaris doesnt have a prototype for this */
+int getdomainname(char *, int);
+
+typedef struct {
+    kstat_t **ks;
+    int num;
+    char *name;
+    int nlen;
+} kstat_list_t;
+
+SIGAR_INLINE kid_t sigar_kstat_update(sigar_t *sigar);
+
+int sigar_get_kstats(sigar_t *sigar);
+
+void sigar_init_multi_kstats(sigar_t *sigar);
+
+void sigar_free_multi_kstats(sigar_t *sigar);
+
+int sigar_get_multi_kstats(sigar_t *sigar,
+                           kstat_list_t *kl,
+                           const char *name,
+                           kstat_t **retval);
+
+void sigar_koffsets_lookup(kstat_t *ksp, int *offsets, int kidx);
+
+int sigar_proc_psinfo_get(sigar_t *sigar, sigar_pid_t pid);
+
+int sigar_proc_usage_get(sigar_t *sigar, prusage_t *prusage, sigar_pid_t pid);
+
+int sigar_proc_status_get(sigar_t *sigar, pstatus_t *pstatus, sigar_pid_t pid);
+
+#define CPU_ONLINE(n) \
+    (p_online(n, P_STATUS) == P_ONLINE)
+
+typedef enum {
+    KSTAT_SYSTEM_BOOT_TIME,
+    KSTAT_SYSTEM_LOADAVG_1,
+    KSTAT_SYSTEM_LOADAVG_2,
+    KSTAT_SYSTEM_LOADAVG_3,
+    KSTAT_SYSTEM_MAX
+} kstat_system_off_e;
+
+typedef enum {
+    KSTAT_MEMPAGES_ANON,
+    KSTAT_MEMPAGES_EXEC,
+    KSTAT_MEMPAGES_VNODE,
+    KSTAT_MEMPAGES_MAX
+} kstat_mempages_off_e;
+
+typedef enum {
+    KSTAT_SYSPAGES_FREE,
+    KSTAT_SYSPAGES_MAX
+} kstat_syspages_off_e;
+
+enum {
+    KSTAT_KEYS_system,
+    KSTAT_KEYS_mempages,
+    KSTAT_KEYS_syspages,
+} kstat_keys_e;
+
+typedef struct ps_prochandle * (*proc_grab_func_t)(pid_t, int, int *);
+
+typedef void (*proc_free_func_t)(struct ps_prochandle *);
+
+typedef int (*proc_create_agent_func_t)(struct ps_prochandle *);
+
+typedef void (*proc_destroy_agent_func_t)(struct ps_prochandle *);
+
+typedef void (*proc_objname_func_t)(struct ps_prochandle *,
+                                    uintptr_t, const char *, size_t);
+
+typedef char * (*proc_dirname_func_t)(const char *, char *, size_t);
+
+typedef char * (*proc_exename_func_t)(struct ps_prochandle *, char *, size_t);
+
+typedef int (*proc_fstat64_func_t)(struct ps_prochandle *, int, void *);
+
+typedef int (*proc_getsockopt_func_t)(struct ps_prochandle *,
+                                     int, int, int, void *, int *);
+
+typedef int (*proc_getsockname_func_t)(struct ps_prochandle *,
+                                      int, struct sockaddr *, socklen_t *);
+
+struct sigar_t {
+    SIGAR_T_BASE;
+
+    int solaris_version;
+    int use_ucb_ps;
+
+    kstat_ctl_t *kc;
+
+    /* kstat_lookup() as needed */
+    struct {
+        kstat_t **cpu;
+        kstat_t **cpu_info;
+        processorid_t *cpuid;
+        unsigned int lcpu; /* number malloced slots in the cpu array above */
+        kstat_t *system;
+        kstat_t *syspages;
+        kstat_t *mempages;
+    } ks;
+
+    struct {
+        int system[KSTAT_SYSTEM_MAX];
+        int mempages[KSTAT_MEMPAGES_MAX];
+        int syspages[KSTAT_SYSPAGES_MAX];
+    } koffsets;
+    
+    int pagesize;
+
+    time_t last_getprocs;
+    sigar_pid_t last_pid;
+    psinfo_t *pinfo;
+    sigar_cpu_list_t cpulist;
+
+    /* libproc.so interface */
+    void *plib;
+    proc_grab_func_t pgrab;
+    proc_free_func_t pfree;
+    proc_create_agent_func_t pcreate_agent;
+    proc_destroy_agent_func_t pdestroy_agent;
+    proc_objname_func_t pobjname;
+    proc_dirname_func_t pdirname;
+    proc_exename_func_t pexename;
+    proc_fstat64_func_t pfstat64;
+    proc_getsockopt_func_t pgetsockopt;
+    proc_getsockname_func_t pgetsockname;
+
+    sigar_cache_t *pargs;
+
+    solaris_mib2_t mib2;
+};
+
+#ifdef SIGAR_64BIT
+#define KSTAT_UINT ui64
+#else
+#define KSTAT_UINT ui32
+#endif
+
+#define kSTAT_exists(v, type) \
+    (sigar->koffsets.type[v] != -2)
+
+#define kSTAT_ptr(v, type) \
+    ((kstat_named_t *)ksp->ks_data + sigar->koffsets.type[v])
+
+#define kSTAT_uint(v, type) \
+    (kSTAT_exists(v, type) ? kSTAT_ptr(v, type)->value.KSTAT_UINT : 0)
+
+#define kSTAT_ui32(v, type) \
+    (kSTAT_exists(v, type) ? kSTAT_ptr(v, type)->value.ui32 : 0)
+
+#define kSYSTEM(v) kSTAT_ui32(v, system)
+
+#define kMEMPAGES(v) kSTAT_uint(v, mempages)
+
+#define kSYSPAGES(v) kSTAT_uint(v, syspages)
+
+#define sigar_koffsets_init(sigar, ksp, type) \
+    if (sigar->koffsets.type[0] == -1) \
+        sigar_koffsets_lookup(ksp, sigar->koffsets.type, KSTAT_KEYS_##type)
+
+#define sigar_koffsets_init_system(sigar, ksp) \
+    sigar_koffsets_init(sigar, ksp, system)
+
+#define sigar_koffsets_init_mempages(sigar, ksp) \
+    sigar_koffsets_init(sigar, ksp, mempages)
+
+#define sigar_koffsets_init_syspages(sigar, ksp) \
+    sigar_koffsets_init(sigar, ksp, syspages)
+
+#define HAVE_READDIR_R
+#define HAVE_GETPWNAM_R
+#define HAVE_GETPWUID_R
+
+#define SIGAR_EMIB2 (SIGAR_OS_START_ERROR+1)
+
+#endif /* SIGAR_OS_H */
+