1 /*

     2  * Copyright (c) 2011, Oracle and/or its affiliates. All rights reserved.

     3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

     4  *

     5  * This code is free software; you can redistribute it and/or modify it

     6  * under the terms of the GNU General Public License version 2 only, as

     7  * published by the Free Software Foundation.  Oracle designates this

     8  * particular file as subject to the "Classpath" exception as provided

     9  * by Oracle in the LICENSE file that accompanied this code.

    10  *

    11  * This code is distributed in the hope that it will be useful, but WITHOUT

    12  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

    13  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

    14  * version 2 for more details (a copy is included in the LICENSE file that

    15  * accompanied this code).

    16  *

    17  * You should have received a copy of the GNU General Public License version

    18  * 2 along with this work; if not, write to the Free Software Foundation,

    19  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

    20  *

    21  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

    22  * or visit www.oracle.com if you need additional information or have any

    23  * questions.

    24  */

    25 

    26 #include <stdio.h>

    27 #include <stdint.h>

    28 #include <stdarg.h>

    29 #include <unistd.h>

    30 #include <errno.h>

    31 #include <string.h>

    32 #include <sys/resource.h>

    33 #include <sys/types.h>

    34 #include <dirent.h>

    35 #include <stdlib.h>

    36 #include <dlfcn.h>

    37 #include <pthread.h>

    38 #include "com_sun_management_UnixOperatingSystem.h"

    39 

    40 struct ticks {

    41     uint64_t  used;

    42     uint64_t  usedKernel;

    43     uint64_t  total;

    44 };

    45 

    46 typedef struct ticks ticks;

    47 

    48 typedef enum {

    49     CPU_LOAD_VM_ONLY,

    50     CPU_LOAD_GLOBAL,

    51 } CpuLoadTarget;

    52 

    53 static struct perfbuf {

    54     int   nProcs;

    55     ticks jvmTicks;

    56     ticks cpuTicks;

    57     ticks *cpus;

    58 } counters;

    59 

    60 #define DEC_64 "%lld"

    61 

    62 static void next_line(FILE *f) {

    63     while (fgetc(f) != '\n');

    64 }

    65 

    66 /**

    67  * Return the total number of ticks since the system was booted.

    68  * If the usedTicks parameter is not NULL, it will be filled with

    69  * the number of ticks spent on actual processes (user, system or

    70  * nice processes) since system boot. Note that this is the total number

    71  * of "executed" ticks on _all_ CPU:s, that is on a n-way system it is

    72  * n times the number of ticks that has passed in clock time.

    73  *

    74  * Returns a negative value if the reading of the ticks failed.

    75  */

    76 static int get_totalticks(int which, ticks *pticks) {

    77     FILE         *fh;

    78     uint64_t        userTicks, niceTicks, systemTicks, idleTicks;

    79     int             n;

    80 

    81     if((fh = fopen("/proc/stat", "r")) == NULL) {

    82         return -1;

    83     }

    84 

    85     n = fscanf(fh, "cpu " DEC_64 " " DEC_64 " " DEC_64 " " DEC_64,

    86            &userTicks, &niceTicks, &systemTicks, &idleTicks);

    87 

    88     // Move to next line

    89     next_line(fh);

    90 

    91     //find the line for requested cpu faster to just iterate linefeeds?

    92     if (which != -1) {

    93         int i;

    94         for (i = 0; i < which; i++) {

    95             if (fscanf(fh, "cpu%*d " DEC_64 " " DEC_64 " " DEC_64 " " DEC_64, &userTicks, &niceTicks, &systemTicks, &idleTicks) != 4) {

    96                 fclose(fh);

    97                 return -2;

    98             }

    99             next_line(fh);

   100         }

   101         n = fscanf(fh, "cpu%*d " DEC_64 " " DEC_64 " " DEC_64 " " DEC_64 "\n",

   102            &userTicks, &niceTicks, &systemTicks, &idleTicks);

   103     }

   104 

   105     fclose(fh);

   106     if (n != 4) {

   107         return -2;

   108     }

   109 

   110     pticks->used       = userTicks + niceTicks;

   111     pticks->usedKernel = systemTicks;

   112     pticks->total      = userTicks + niceTicks + systemTicks + idleTicks;

   113 

   114     return 0;

   115 }

   116 

   117 static int vread_statdata(const char *procfile, const char *fmt, va_list args) {

   118     FILE    *f;

   119     int     n;

   120     char     buf[2048];

   121 

   122     if ((f = fopen(procfile, "r")) == NULL) {

   123         return -1;

   124     }

   125 

   126     if ((n = fread(buf, 1, sizeof(buf), f)) != -1) {

   127     char *tmp;

   128 

   129     buf[n-1] = '\0';

   130     /** skip through pid and exec name. the exec name _could be wacky_ (renamed) and

   131      *  make scanf go mupp.

   132      */

   133     if ((tmp = strrchr(buf, ')')) != NULL) {

   134         // skip the ')' and the following space but check that the buffer is long enough

   135         tmp += 2;

   136         if (tmp < buf + n) {

   137         n = vsscanf(tmp, fmt, args);

   138         }

   139     }

   140     }

   141 

   142     fclose(f);

   143 

   144     return n;

   145 }

   146 

   147 static int read_statdata(const char *procfile, const char *fmt, ...) {

   148     int       n;

   149     va_list args;

   150 

   151     va_start(args, fmt);

   152     n = vread_statdata(procfile, fmt, args);

   153     va_end(args);

   154     return n;

   155 }

   156 

   157 /** read user and system ticks from a named procfile, assumed to be in 'stat' format then. */

   158 static int read_ticks(const char *procfile, uint64_t *userTicks, uint64_t *systemTicks) {

   159     return read_statdata(procfile, "%*c %*d %*d %*d %*d %*d %*u %*u %*u %*u %*u "DEC_64" "DEC_64,

   160              userTicks, systemTicks

   161              );

   162 }

   163 

   164 /**

   165  * Return the number of ticks spent in any of the processes belonging

   166  * to the JVM on any CPU.

   167  */

   168 static int get_jvmticks(ticks *pticks) {

   169     uint64_t userTicks;

   170     uint64_t systemTicks;

   171 

   172     if (read_ticks("/proc/self/stat", &userTicks, &systemTicks) < 0) {

   173         return -1;

   174     }

   175 

   176     // get the total

   177     if (get_totalticks(-1, pticks) < 0) {

   178         return -1;

   179     }

   180 

   181     pticks->used       = userTicks;

   182     pticks->usedKernel = systemTicks;

   183 

   184     return 0;

   185 }

   186 

   187 /**

   188  * This method must be called first, before any data can be gathererd.

   189  */

   190 int perfInit() {

   191     static int initialized=1;

   192 

   193     if (!initialized) {

   194         int  i;

   195 

   196         int n = sysconf(_SC_NPROCESSORS_ONLN);

   197         if (n <= 0) {

   198             n = 1;

   199         }

   200 

   201         counters.cpus = calloc(n,sizeof(ticks));

   202         if (counters.cpus != NULL)  {

   203             // For the CPU load

   204             get_totalticks(-1, &counters.cpuTicks);

   205 

   206             for (i = 0; i < n; i++) {

   207                 get_totalticks(i, &counters.cpus[i]);

   208             }

   209             // For JVM load

   210             get_jvmticks(&counters.jvmTicks);

   211             initialized = 1;

   212         }

   213     }

   214 

   215     return initialized ? 0 : -1;

   216 }

   217 

   218 #define MAX(a,b) (a>b?a:b)

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

   220 

   221 static pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;

   222 

   223 /**

   224  * Return the load of the CPU as a double. 1.0 means the CPU process uses all

   225  * available time for user or system processes, 0.0 means the CPU uses all time

   226  * being idle.

   227  *

   228  * Returns a negative value if there is a problem in determining the CPU load.

   229  */

   230 

   231 static double get_cpuload_internal(int which, double *pkernelLoad, CpuLoadTarget target) {

   232     uint64_t udiff, kdiff, tdiff;

   233     ticks *pticks, tmp;

   234     double user_load = -1.0;

   235     int failed = 0;

   236 

   237     *pkernelLoad = 0.0;

   238 

   239     pthread_mutex_lock(&lock);

   240 

   241     if(perfInit() == 0) {

   242 

   243         if (target == CPU_LOAD_VM_ONLY) {

   244             pticks = &counters.jvmTicks;

   245         } else if (which == -1) {

   246             pticks = &counters.cpuTicks;

   247         } else {

   248             pticks = &counters.cpus[which];

   249         }

   250 

   251         tmp = *pticks;

   252 

   253         if (target == CPU_LOAD_VM_ONLY) {

   254             if (get_jvmticks(pticks) != 0) {

   255                 failed = 1;

   256             }

   257         } else if (get_totalticks(which, pticks) < 0) {

   258             failed = 1;

   259         }

   260 

   261         if(!failed) {

   262             // seems like we sometimes end up with less kernel ticks when

   263             // reading /proc/self/stat a second time, timing issue between cpus?

   264             if (pticks->usedKernel < tmp.usedKernel) {

   265                 kdiff = 0;

   266             } else {

   267                 kdiff = pticks->usedKernel - tmp.usedKernel;

   268             }

   269             tdiff = pticks->total - tmp.total;

   270             udiff = pticks->used - tmp.used;

   271 

   272             if (tdiff == 0) {

   273                 user_load = 0;

   274             } else {

   275                 if (tdiff < (udiff + kdiff)) {

   276                     tdiff = udiff + kdiff;

   277                 }

   278                 *pkernelLoad = (kdiff / (double)tdiff);

   279                 // BUG9044876, normalize return values to sane values

   280                 *pkernelLoad = MAX(*pkernelLoad, 0.0);

   281                 *pkernelLoad = MIN(*pkernelLoad, 1.0);

   282 

   283                 user_load = (udiff / (double)tdiff);

   284                 user_load = MAX(user_load, 0.0);

   285                 user_load = MIN(user_load, 1.0);

   286             }

   287         }

   288     }

   289     pthread_mutex_unlock(&lock);

   290     return user_load;

   291 }

   292 

   293 double get_cpu_load(int which) {

   294     double u, s;

   295     u = get_cpuload_internal(which, &s, CPU_LOAD_GLOBAL);

   296     if (u < 0) {

   297         return -1.0;

   298     }

   299     // Cap total systemload to 1.0

   300     return MIN((u + s), 1.0);

   301 }

   302 

   303 double get_process_load() {

   304     double u, s;

   305     u = get_cpuload_internal(-1, &s, CPU_LOAD_VM_ONLY);

   306     if (u < 0) {

   307         return -1.0;

   308     }

   309     return u + s;

   310 }

   311 

   312 JNIEXPORT jdouble JNICALL

   313 Java_com_sun_management_UnixOperatingSystem_getSystemCpuLoad

   314 (JNIEnv *env, jobject dummy)

   315 {

   316     if(perfInit() == 0) {

   317         return get_cpu_load(-1);

   318     } else {

   319         return -1.0;

   320     }

   321 }

   322 

   323 JNIEXPORT jdouble JNICALL

   324 Java_com_sun_management_UnixOperatingSystem_getProcessCpuLoad

   325 (JNIEnv *env, jobject dummy)

   326 {

   327     if(perfInit() == 0) {

   328         return get_process_load();

   329     } else {

   330         return -1.0;

   331     }

   332 }