jdk/jdk/src/solaris/native/com/sun/management/SolarisOperatingSystem.c

/*
 * Copyright (c) 2011, Oracle and/or its affiliates. All rights reserved.
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 *
 * This code is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 only, as
 * published by the Free Software Foundation.  Oracle designates this
 * particular file as subject to the "Classpath" exception as provided
 * by Oracle in the LICENSE file that accompanied this code.
 *
 * This code is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
 * version 2 for more details (a copy is included in the LICENSE file that
 * accompanied this code).
 *
 * You should have received a copy of the GNU General Public License version
 * 2 along with this work; if not, write to the Free Software Foundation,
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
 *
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
 * or visit www.oracle.com if you need additional information or have any
 * questions.
 */

#include <fcntl.h>
#include <kstat.h>
#include <procfs.h>
#include <unistd.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <sys/sysinfo.h>
#include <sys/lwp.h>
#include <pthread.h>
#include <utmpx.h>
#include <dlfcn.h>
#include <sys/loadavg.h>
#include <jni.h>
#include "jvm.h"
#include "com_sun_management_UnixOperatingSystem.h"

typedef struct {
    kstat_t *kstat;
    uint64_t  last_idle;
    uint64_t  last_total;
    double  last_ratio;
} cpuload_t;

static cpuload_t   *cpu_loads = NULL;
static unsigned int num_cpus;
static kstat_ctl_t *kstat_ctrl = NULL;

static void map_cpu_kstat_counters() {
    kstat_t     *kstat;
    int          i;

    // Get number of CPU(s)
    if ((num_cpus = sysconf(_SC_NPROCESSORS_ONLN)) == -1) {
        num_cpus = 1;
    }

    // Data structure for saving CPU load
    if ((cpu_loads = calloc(num_cpus,sizeof(cpuload_t))) == NULL) {
        return;
    }

    // Get kstat cpu_stat counters for every CPU
    // (loop over kstat to find our cpu_stat(s)
    i = 0;
    for (kstat = kstat_ctrl->kc_chain; kstat != NULL; kstat = kstat->ks_next) {
        if (strncmp(kstat->ks_module, "cpu_stat", 8) == 0) {

            if (kstat_read(kstat_ctrl, kstat, NULL) == -1) {
            // Failed to initialize kstat for this CPU so ignore it
            continue;
            }

            if (i == num_cpus) {
            // Found more cpu_stats than reported CPUs
            break;
            }

            cpu_loads[i++].kstat = kstat;
        }
    }
}

static int init_cpu_kstat_counters() {
    static int initialized = 0;

    // Concurrence in this method is prevented by the lock in
    // the calling method get_cpu_load();
    if(!initialized) {
        if ((kstat_ctrl = kstat_open()) != NULL) {
            map_cpu_kstat_counters();
            initialized = 1;
        }
    }
    return initialized ? 0 : -1;
}

static void update_cpu_kstat_counters() {
    if(kstat_chain_update(kstat_ctrl) != 0) {
        free(cpu_loads);
        map_cpu_kstat_counters();
    }
}

int read_cpustat(cpuload_t *load, cpu_stat_t *cpu_stat) {
    if (load->kstat == NULL) {
        // no handle.
        return -1;
    }
    if (kstat_read(kstat_ctrl, load->kstat, cpu_stat) == -1) {
        //  disabling for now, a kstat chain update is likely to happen next time
        load->kstat = NULL;
        return -1;
    }
    return 0;
}

double get_single_cpu_load(unsigned int n) {
    cpuload_t  *load;
    cpu_stat_t  cpu_stat;
    uint_t     *usage;
    uint64_t          c_idle;
    uint64_t          c_total;
    uint64_t          d_idle;
    uint64_t          d_total;
    int           i;

    if (n >= num_cpus) {
        return -1.0;
    }

    load = &cpu_loads[n];
    if (read_cpustat(load, &cpu_stat) < 0) {
        return -1.0;
    }

    usage   = cpu_stat.cpu_sysinfo.cpu;
    c_idle  = usage[CPU_IDLE];

    for (c_total = 0, i = 0; i < CPU_STATES; i++) {
        c_total += usage[i];
    }

    // Calculate diff against previous snapshot
    d_idle  = c_idle - load->last_idle;
    d_total = c_total - load->last_total;

    /** update if weve moved */
    if (d_total > 0) {
        // Save current values for next time around
        load->last_idle  = c_idle;
        load->last_total = c_total;
        load->last_ratio = (double) (d_total - d_idle) / d_total;
    }

    return load->last_ratio;
}

int get_info(const char *path, void *info, size_t s, off_t o) {
    int fd;
    int ret = 0;
    if ((fd = open(path, O_RDONLY)) < 0) {
        return -1;
    }
    if (pread(fd, info, s, o) != s) {
        ret = -1;
    }
    close(fd);
    return ret;
}

#define MIN(a, b)           ((a < b) ? a : b)

static pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;

/**
 * Return the cpu load (0-1) for proc number 'which' (or average all if which == -1)
 */
double  get_cpu_load(int which) {
    double load =.0;

    pthread_mutex_lock(&lock);
    if(init_cpu_kstat_counters()==0) {

        update_cpu_kstat_counters();

        if (which == -1) {
            unsigned int i;
            double       t;

            for (t = .0, i = 0; i < num_cpus; i++) {
                t += get_single_cpu_load(i);
            }

            // Cap total systemload to 1.0
            load = MIN((t / num_cpus), 1.0);
        } else {
            load = MIN(get_single_cpu_load(which), 1.0);
        }
    } else {
        load = -1.0;
    }
    pthread_mutex_unlock(&lock);

    return load;
}

/**
 * Return the cpu load (0-1) for the current process (i.e the JVM)
 * or -1.0 if the get_info() call failed
 */
double get_process_load(void) {
    psinfo_t info;

    // Get the percentage of "recent cpu usage" from all the lwp:s in the JVM:s
    // process. This is returned as a value between 0.0 and 1.0 multiplied by 0x8000.
    if (get_info("/proc/self/psinfo",&info.pr_pctcpu, sizeof(info.pr_pctcpu), offsetof(psinfo_t, pr_pctcpu)) == 0) {
        return (double) info.pr_pctcpu / 0x8000;
    }
    return -1.0;
}

JNIEXPORT jdouble JNICALL
Java_com_sun_management_UnixOperatingSystem_getSystemCpuLoad
(JNIEnv *env, jobject dummy)
{
    return get_cpu_load(-1);
}

JNIEXPORT jdouble JNICALL
Java_com_sun_management_UnixOperatingSystem_getProcessCpuLoad
(JNIEnv *env, jobject dummy)
{
    return get_process_load();
}