lib/getloadavg.c

   1 /* Get the system load averages.
   2
   3    Copyright (C) 1985, 1986, 1987, 1988, 1989, 1991, 1992, 1993, 1994,
   4    1995, 1997, 1999, 2000, 2003, 2004, 2005 Free Software Foundation, Inc.
   5
   6    NOTE: The canonical source of this file is maintained with gnulib.
   7    Bugs can be reported to bug-gnulib@gnu.org.
   8
   9    This program is free software; you can redistribute it and/or modify
  10    it under the terms of the GNU General Public License as published by
  11    the Free Software Foundation; either version 2, or (at your option)
  12    any later version.
  13
  14    This program is distributed in the hope that it will be useful,
  15    but WITHOUT ANY WARRANTY; without even the implied warranty of
  16    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17    GNU General Public License for more details.
  18
  19    You should have received a copy of the GNU General Public License
  20    along with this program; if not, write to the Free Software
  21    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
  22    USA.  */
  23
  24 /* Compile-time symbols that this file uses:
  25
  26    HAVE_PSTAT_GETDYNAMIC        Define this if your system has the
  27                                 pstat_getdynamic function.  I think it
  28                                 is unique to HPUX9.  The best way to get the
  29                                 definition is through the AC_FUNC_GETLOADAVG
  30                                 macro that comes with autoconf 2.13 or newer.
  31                                 If that isn't an option, then just put
  32                                 AC_CHECK_FUNCS(pstat_getdynamic) in your
  33                                 configure.in file.
  34    FIXUP_KERNEL_SYMBOL_ADDR()   Adjust address in returned struct nlist.
  35    KERNEL_FILE                  Name of the kernel file to nlist.
  36    LDAV_CVT()                   Scale the load average from the kernel.
  37                                 Returns a double.
  38    LDAV_SYMBOL                  Name of kernel symbol giving load average.
  39    LOAD_AVE_TYPE                Type of the load average array in the kernel.
  40                                 Must be defined unless one of
  41                                 apollo, DGUX, NeXT, or UMAX is defined;
  42                                 or we have libkstat;
  43                                 otherwise, no load average is available.
  44    HAVE_NLIST_H                 nlist.h is available.  NLIST_STRUCT defaults
  45                                 to this.
  46    NLIST_STRUCT                 Include nlist.h, not a.out.h, and
  47                                 the nlist n_name element is a pointer,
  48                                 not an array.
  49    HAVE_STRUCT_NLIST_N_UN_N_NAME `n_un.n_name' is member of `struct nlist'.
  50    LINUX_LDAV_FILE              [__linux__, __CYGWIN__]: File containing
  51                                 load averages.
  52
  53    Specific system predefines this file uses, aside from setting
  54    default values if not emacs:
  55
  56    apollo
  57    BSD                          Real BSD, not just BSD-like.
  58    convex
  59    DGUX
  60    eunice                       UNIX emulator under VMS.
  61    hpux
  62    __MSDOS__                    No-op for MSDOS.
  63    NeXT
  64    sgi
  65    sequent                      Sequent Dynix 3.x.x (BSD)
  66    _SEQUENT_                    Sequent DYNIX/ptx 1.x.x (SYSV)
  67    sony_news                    NEWS-OS (works at least for 4.1C)
  68    UMAX
  69    UMAX4_3
  70    VMS
  71    WINDOWS32                    No-op for Windows95/NT.
  72    __linux__                    Linux: assumes /proc file system mounted.
  73                                 Support from Michael K. Johnson.
  74    __CYGWIN__                   Cygwin emulates linux /proc/loadavg.
  75    __NetBSD__                   NetBSD: assumes /kern file system mounted.
  76
  77    In addition, to avoid nesting many #ifdefs, we internally set
  78    LDAV_DONE to indicate that the load average has been computed.
  79
  80    We also #define LDAV_PRIVILEGED if a program will require
  81    special installation to be able to call getloadavg.  */
  82
  83 /* This should always be first.  */
  84 #ifdef HAVE_CONFIG_H
  85 # include <config.h>
  86 #endif
  87
  88 #include <errno.h>
  89 #include <stdbool.h>
  90 #include <stdio.h>
  91 #include <stdlib.h>
  92
  93 /* Exclude all the code except the test program at the end
  94    if the system has its own `getloadavg' function.  */
  95
  96 #ifndef HAVE_GETLOADAVG
  97
  98 # include <sys/types.h>
  99
 100 /* Both the Emacs and non-Emacs sections want this.  Some
 101    configuration files' definitions for the LOAD_AVE_CVT macro (like
 102    sparc.h's) use macros like FSCALE, defined here.  */
 103 # if defined (unix) || defined (__unix)
 104 #  include <sys/param.h>
 105 # endif
 106
 107 # include "c-strtod.h"
 108 # include "cloexec.h"
 109 # include "intprops.h"
 110 # include "xalloc.h"
 111
 112 /* The existing Emacs configuration files define a macro called
 113    LOAD_AVE_CVT, which accepts a value of type LOAD_AVE_TYPE, and
 114    returns the load average multiplied by 100.  What we actually want
 115    is a macro called LDAV_CVT, which returns the load average as an
 116    unmultiplied double.
 117
 118    For backwards compatibility, we'll define LDAV_CVT in terms of
 119    LOAD_AVE_CVT, but future machine config files should just define
 120    LDAV_CVT directly.  */
 121
 122 # if !defined (LDAV_CVT) && defined (LOAD_AVE_CVT)
 123 #  define LDAV_CVT(n) (LOAD_AVE_CVT (n) / 100.0)
 124 # endif
 125
 126 # if !defined (BSD) && defined (ultrix)
 127 /* Ultrix behaves like BSD on Vaxen.  */
 128 #  define BSD
 129 # endif
 130
 131 # ifdef NeXT
 132 /* NeXT in the 2.{0,1,2} releases defines BSD in <sys/param.h>, which
 133    conflicts with the definition understood in this file, that this
 134    really is BSD. */
 135 #  undef BSD
 136
 137 /* NeXT defines FSCALE in <sys/param.h>.  However, we take FSCALE being
 138    defined to mean that the nlist method should be used, which is not true.  */
 139 #  undef FSCALE
 140 # endif
 141
 142 /* Same issues as for NeXT apply to the HURD-based GNU system.  */
 143 # ifdef __GNU__
 144 #  undef BSD
 145 #  undef FSCALE
 146 # endif /* __GNU__ */
 147
 148 /* Set values that are different from the defaults, which are
 149    set a little farther down with #ifndef.  */
 150
 151
 152 /* Some shorthands.  */
 153
 154 # if defined (HPUX) && !defined (hpux)
 155 #  define hpux
 156 # endif
 157
 158 # if defined (__hpux) && !defined (hpux)
 159 #  define hpux
 160 # endif
 161
 162 # if defined (__sun) && !defined (sun)
 163 #  define sun
 164 # endif
 165
 166 # if defined (hp300) && !defined (hpux)
 167 #  define MORE_BSD
 168 # endif
 169
 170 # if defined (ultrix) && defined (mips)
 171 #  define decstation
 172 # endif
 173
 174 # if defined (__SVR4) && !defined (SVR4)
 175 #  define SVR4
 176 # endif
 177
 178 # if (defined (sun) && defined (SVR4)) || defined (SOLARIS2)
 179 #  define SUNOS_5
 180 # endif
 181
 182 # if defined (__osf__) && (defined (__alpha) || defined (__alpha__))
 183 #  define OSF_ALPHA
 184 #  include <sys/mbuf.h>
 185 #  include <sys/socket.h>
 186 #  include <net/route.h>
 187 #  include <sys/table.h>
 188 # endif
 189
 190 # if defined (__osf__) && (defined (mips) || defined (__mips__))
 191 #  define OSF_MIPS
 192 #  include <sys/table.h>
 193 # endif
 194
 195 /* UTek's /bin/cc on the 4300 has no architecture specific cpp define by
 196    default, but _MACH_IND_SYS_TYPES is defined in <sys/types.h>.  Combine
 197    that with a couple of other things and we'll have a unique match.  */
 198 # if !defined (tek4300) && defined (unix) && defined (m68k) && defined (mc68000) && defined (mc68020) && defined (_MACH_IND_SYS_TYPES)
 199 #  define tek4300                       /* Define by emacs, but not by other users.  */
 200 # endif
 201
 202
 203 /* VAX C can't handle multi-line #ifs, or lines longer than 256 chars.  */
 204 # ifndef LOAD_AVE_TYPE
 205
 206 #  ifdef MORE_BSD
 207 #   define LOAD_AVE_TYPE long
 208 #  endif
 209
 210 #  ifdef sun
 211 #   define LOAD_AVE_TYPE long
 212 #  endif
 213
 214 #  ifdef decstation
 215 #   define LOAD_AVE_TYPE long
 216 #  endif
 217
 218 #  ifdef _SEQUENT_
 219 #   define LOAD_AVE_TYPE long
 220 #  endif
 221
 222 #  ifdef sgi
 223 #   define LOAD_AVE_TYPE long
 224 #  endif
 225
 226 #  ifdef SVR4
 227 #   define LOAD_AVE_TYPE long
 228 #  endif
 229
 230 #  ifdef sony_news
 231 #   define LOAD_AVE_TYPE long
 232 #  endif
 233
 234 #  ifdef sequent
 235 #   define LOAD_AVE_TYPE long
 236 #  endif
 237
 238 #  ifdef OSF_ALPHA
 239 #   define LOAD_AVE_TYPE long
 240 #  endif
 241
 242 #  if defined (ardent) && defined (titan)
 243 #   define LOAD_AVE_TYPE long
 244 #  endif
 245
 246 #  ifdef tek4300
 247 #   define LOAD_AVE_TYPE long
 248 #  endif
 249
 250 #  if defined (alliant) && defined (i860) /* Alliant FX/2800 */
 251 #   define LOAD_AVE_TYPE long
 252 #  endif
 253
 254 #  ifdef _AIX
 255 #   define LOAD_AVE_TYPE long
 256 #  endif
 257
 258 #  ifdef convex
 259 #   define LOAD_AVE_TYPE double
 260 #   ifndef LDAV_CVT
 261 #    define LDAV_CVT(n) (n)
 262 #   endif
 263 #  endif
 264
 265 # endif /* No LOAD_AVE_TYPE.  */
 266
 267 # ifdef OSF_ALPHA
 268 /* <sys/param.h> defines an incorrect value for FSCALE on Alpha OSF/1,
 269    according to ghazi@noc.rutgers.edu.  */
 270 #  undef FSCALE
 271 #  define FSCALE 1024.0
 272 # endif
 273
 274 # if defined (alliant) && defined (i860) /* Alliant FX/2800 */
 275 /* <sys/param.h> defines an incorrect value for FSCALE on an
 276    Alliant FX/2800 Concentrix 2.2, according to ghazi@noc.rutgers.edu.  */
 277 #  undef FSCALE
 278 #  define FSCALE 100.0
 279 # endif
 280
 281
 282 # ifndef        FSCALE
 283
 284 /* SunOS and some others define FSCALE in sys/param.h.  */
 285
 286 #  ifdef MORE_BSD
 287 #   define FSCALE 2048.0
 288 #  endif
 289
 290 #  if defined (MIPS) || defined (SVR4) || defined (decstation)
 291 #   define FSCALE 256
 292 #  endif
 293
 294 #  if defined (sgi) || defined (sequent)
 295 /* Sometimes both MIPS and sgi are defined, so FSCALE was just defined
 296    above under #ifdef MIPS.  But we want the sgi value.  */
 297 #   undef FSCALE
 298 #   define FSCALE 1000.0
 299 #  endif
 300
 301 #  if defined (ardent) && defined (titan)
 302 #   define FSCALE 65536.0
 303 #  endif
 304
 305 #  ifdef tek4300
 306 #   define FSCALE 100.0
 307 #  endif
 308
 309 #  ifdef _AIX
 310 #   define FSCALE 65536.0
 311 #  endif
 312
 313 # endif /* Not FSCALE.  */
 314
 315 # if !defined (LDAV_CVT) && defined (FSCALE)
 316 #  define LDAV_CVT(n) (((double) (n)) / FSCALE)
 317 # endif
 318
 319 # ifndef NLIST_STRUCT
 320 #  if HAVE_NLIST_H
 321 #   define NLIST_STRUCT
 322 #  endif
 323 # endif
 324
 325 # if defined (sgi) || (defined (mips) && !defined (BSD))
 326 #  define FIXUP_KERNEL_SYMBOL_ADDR(nl) ((nl)[0].n_value &= ~(1 << 31))
 327 # endif
 328
 329
 330 # if !defined (KERNEL_FILE) && defined (sequent)
 331 #  define KERNEL_FILE "/dynix"
 332 # endif
 333
 334 # if !defined (KERNEL_FILE) && defined (hpux)
 335 #  define KERNEL_FILE "/hp-ux"
 336 # endif
 337
 338 # if !defined (KERNEL_FILE) && (defined (_SEQUENT_) || defined (MIPS) || defined (SVR4) || defined (ISC) || defined (sgi) || (defined (ardent) && defined (titan)))
 339 #  define KERNEL_FILE "/unix"
 340 # endif
 341
 342
 343 # if !defined (LDAV_SYMBOL) && defined (alliant)
 344 #  define LDAV_SYMBOL "_Loadavg"
 345 # endif
 346
 347 # if !defined (LDAV_SYMBOL) && ((defined (hpux) && !defined (hp9000s300)) || defined (_SEQUENT_) || defined (SVR4) || defined (ISC) || defined (sgi) || (defined (ardent) && defined (titan)) || defined (_AIX))
 348 #  define LDAV_SYMBOL "avenrun"
 349 # endif
 350
 351 # include <unistd.h>
 352
 353 /* LOAD_AVE_TYPE should only get defined if we're going to use the
 354    nlist method.  */
 355 # if !defined (LOAD_AVE_TYPE) && (defined (BSD) || defined (LDAV_CVT) || defined (KERNEL_FILE) || defined (LDAV_SYMBOL))
 356 #  define LOAD_AVE_TYPE double
 357 # endif
 358
 359 # ifdef LOAD_AVE_TYPE
 360
 361 #  ifndef VMS
 362 #   ifndef __linux__
 363 #    ifndef NLIST_STRUCT
 364 #     include <a.out.h>
 365 #    else /* NLIST_STRUCT */
 366 #     include <nlist.h>
 367 #    endif /* NLIST_STRUCT */
 368
 369 #    ifdef SUNOS_5
 370 #     include <fcntl.h>
 371 #     include <kvm.h>
 372 #     include <kstat.h>
 373 #    endif
 374
 375 #    if defined (hpux) && defined (HAVE_PSTAT_GETDYNAMIC)
 376 #     include <sys/pstat.h>
 377 #    endif
 378
 379 #    ifndef KERNEL_FILE
 380 #     define KERNEL_FILE "/vmunix"
 381 #    endif /* KERNEL_FILE */
 382
 383 #    ifndef LDAV_SYMBOL
 384 #     define LDAV_SYMBOL "_avenrun"
 385 #    endif /* LDAV_SYMBOL */
 386 #   endif /* __linux__ */
 387
 388 #  else /* VMS */
 389
 390 #   ifndef eunice
 391 #    include <iodef.h>
 392 #    include <descrip.h>
 393 #   else /* eunice */
 394 #    include <vms/iodef.h>
 395 #   endif /* eunice */
 396 #  endif /* VMS */
 397
 398 #  ifndef LDAV_CVT
 399 #   define LDAV_CVT(n) ((double) (n))
 400 #  endif /* !LDAV_CVT */
 401
 402 # endif /* LOAD_AVE_TYPE */
 403
 404 # if defined (__GNU__) && !defined (NeXT)
 405 /* Note that NeXT Openstep defines __GNU__ even though it should not.  */
 406 /* GNU system acts much like NeXT, for load average purposes,
 407    but not exactly.  */
 408 #  define NeXT
 409 #  define host_self mach_host_self
 410 # endif
 411
 412 # ifdef NeXT
 413 #  ifdef HAVE_MACH_MACH_H
 414 #   include <mach/mach.h>
 415 #  else
 416 #   include <mach.h>
 417 #  endif
 418 # endif /* NeXT */
 419
 420 # ifdef sgi
 421 #  include <sys/sysmp.h>
 422 # endif /* sgi */
 423
 424 # ifdef UMAX
 425 #  include <signal.h>
 426 #  include <sys/time.h>
 427 #  include <sys/wait.h>
 428 #  include <sys/syscall.h>
 429
 430 #  ifdef UMAX_43
 431 #   include <machine/cpu.h>
 432 #   include <inq_stats/statistics.h>
 433 #   include <inq_stats/sysstats.h>
 434 #   include <inq_stats/cpustats.h>
 435 #   include <inq_stats/procstats.h>
 436 #  else /* Not UMAX_43.  */
 437 #   include <sys/sysdefs.h>
 438 #   include <sys/statistics.h>
 439 #   include <sys/sysstats.h>
 440 #   include <sys/cpudefs.h>
 441 #   include <sys/cpustats.h>
 442 #   include <sys/procstats.h>
 443 #  endif /* Not UMAX_43.  */
 444 # endif /* UMAX */
 445
 446 # ifdef DGUX
 447 #  include <sys/dg_sys_info.h>
 448 # endif
 449
 450 # include "fcntl--.h"
 451 \f
 452 /* Avoid static vars inside a function since in HPUX they dump as pure.  */
 453
 454 # ifdef NeXT
 455 static processor_set_t default_set;
 456 static bool getloadavg_initialized;
 457 # endif /* NeXT */
 458
 459 # ifdef UMAX
 460 static unsigned int cpus = 0;
 461 static unsigned int samples;
 462 # endif /* UMAX */
 463
 464 # ifdef DGUX
 465 static struct dg_sys_info_load_info load_info;  /* what-a-mouthful! */
 466 # endif /* DGUX */
 467
 468 # if !defined (HAVE_LIBKSTAT) && defined (LOAD_AVE_TYPE)
 469 /* File descriptor open to /dev/kmem or VMS load ave driver.  */
 470 static int channel;
 471 /* True iff channel is valid.  */
 472 static bool getloadavg_initialized;
 473 /* Offset in kmem to seek to read load average, or 0 means invalid.  */
 474 static long offset;
 475
 476 #  if !defined (VMS) && !defined (sgi) && !defined (__linux__)
 477 static struct nlist nl[2];
 478 #  endif /* Not VMS or sgi */
 479
 480 #  ifdef SUNOS_5
 481 static kvm_t *kd;
 482 #  endif /* SUNOS_5 */
 483
 484 # endif /* LOAD_AVE_TYPE && !HAVE_LIBKSTAT */
 485 \f
 486 /* Put the 1 minute, 5 minute and 15 minute load averages
 487    into the first NELEM elements of LOADAVG.
 488    Return the number written (never more than 3, but may be less than NELEM),
 489    or -1 if an error occurred.  */
 490
 491 int
 492 getloadavg (double loadavg[], int nelem)
 493 {
 494   int elem = 0;                 /* Return value.  */
 495
 496 # ifdef NO_GET_LOAD_AVG
 497 #  define LDAV_DONE
 498   /* Set errno to zero to indicate that there was no particular error;
 499      this function just can't work at all on this system.  */
 500   errno = 0;
 501   elem = -1;
 502 # endif
 503
 504 # if !defined (LDAV_DONE) && defined (HAVE_LIBKSTAT)
 505 /* Use libkstat because we don't have to be root.  */
 506 #  define LDAV_DONE
 507   kstat_ctl_t *kc;
 508   kstat_t *ksp;
 509   kstat_named_t *kn;
 510
 511   kc = kstat_open ();
 512   if (kc == 0)
 513     return -1;
 514   ksp = kstat_lookup (kc, "unix", 0, "system_misc");
 515   if (ksp == 0)
 516     return -1;
 517   if (kstat_read (kc, ksp, 0) == -1)
 518     return -1;
 519
 520
 521   kn = kstat_data_lookup (ksp, "avenrun_1min");
 522   if (kn == 0)
 523     {
 524       /* Return -1 if no load average information is available.  */
 525       nelem = 0;
 526       elem = -1;
 527     }
 528
 529   if (nelem >= 1)
 530     loadavg[elem++] = (double) kn->value.ul / FSCALE;
 531
 532   if (nelem >= 2)
 533     {
 534       kn = kstat_data_lookup (ksp, "avenrun_5min");
 535       if (kn != 0)
 536         {
 537           loadavg[elem++] = (double) kn->value.ul / FSCALE;
 538
 539           if (nelem >= 3)
 540             {
 541               kn = kstat_data_lookup (ksp, "avenrun_15min");
 542               if (kn != 0)
 543                 loadavg[elem++] = (double) kn->value.ul / FSCALE;
 544             }
 545         }
 546     }
 547
 548   kstat_close (kc);
 549 # endif /* HAVE_LIBKSTAT */
 550
 551 # if !defined (LDAV_DONE) && defined (hpux) && defined (HAVE_PSTAT_GETDYNAMIC)
 552 /* Use pstat_getdynamic() because we don't have to be root.  */
 553 #  define LDAV_DONE
 554 #  undef LOAD_AVE_TYPE
 555
 556   struct pst_dynamic dyn_info;
 557   if (pstat_getdynamic (&dyn_info, sizeof (dyn_info), 0, 0) < 0)
 558     return -1;
 559   if (nelem > 0)
 560     loadavg[elem++] = dyn_info.psd_avg_1_min;
 561   if (nelem > 1)
 562     loadavg[elem++] = dyn_info.psd_avg_5_min;
 563   if (nelem > 2)
 564     loadavg[elem++] = dyn_info.psd_avg_15_min;
 565
 566 # endif /* hpux && HAVE_PSTAT_GETDYNAMIC */
 567
 568 # if !defined (LDAV_DONE) && (defined (__linux__) || defined (__CYGWIN__))
 569 #  define LDAV_DONE
 570 #  undef LOAD_AVE_TYPE
 571
 572 #  ifndef LINUX_LDAV_FILE
 573 #   define LINUX_LDAV_FILE "/proc/loadavg"
 574 #  endif
 575
 576   char ldavgbuf[3 * (INT_STRLEN_BOUND (int) + sizeof ".00 ")];
 577   char const *ptr = ldavgbuf;
 578   int fd, count;
 579
 580   fd = open (LINUX_LDAV_FILE, O_RDONLY);
 581   if (fd == -1)
 582     return -1;
 583   count = read (fd, ldavgbuf, sizeof ldavgbuf - 1);
 584   (void) close (fd);
 585   if (count <= 0)
 586     return -1;
 587   ldavgbuf[count] = '\0';
 588
 589   for (elem = 0; elem < nelem; elem++)
 590     {
 591       char *endptr;
 592       double d = c_strtod (ptr, &endptr);
 593       if (ptr == endptr)
 594         {
 595           if (elem == 0)
 596             return -1;
 597           break;
 598         }
 599       loadavg[elem] = d;
 600       ptr = endptr;
 601     }
 602
 603   return elem;
 604
 605 # endif /* __linux__ || __CYGWIN__ */
 606
 607 # if !defined (LDAV_DONE) && defined (__NetBSD__)
 608 #  define LDAV_DONE
 609 #  undef LOAD_AVE_TYPE
 610
 611 #  ifndef NETBSD_LDAV_FILE
 612 #   define NETBSD_LDAV_FILE "/kern/loadavg"
 613 #  endif
 614
 615   unsigned long int load_ave[3], scale;
 616   int count;
 617   FILE *fp;
 618
 619   fp = fopen (NETBSD_LDAV_FILE, "r");
 620   if (fp == NULL)
 621     return -1;
 622   count = fscanf (fp, "%lu %lu %lu %lu\n",
 623                   &load_ave[0], &load_ave[1], &load_ave[2],
 624                   &scale);
 625   (void) fclose (fp);
 626   if (count != 4)
 627     return -1;
 628
 629   for (elem = 0; elem < nelem; elem++)
 630     loadavg[elem] = (double) load_ave[elem] / (double) scale;
 631
 632   return elem;
 633
 634 # endif /* __NetBSD__ */
 635
 636 # if !defined (LDAV_DONE) && defined (NeXT)
 637 #  define LDAV_DONE
 638   /* The NeXT code was adapted from iscreen 3.2.  */
 639
 640   host_t host;
 641   struct processor_set_basic_info info;
 642   unsigned int info_count;
 643
 644   /* We only know how to get the 1-minute average for this system,
 645      so even if the caller asks for more than 1, we only return 1.  */
 646
 647   if (!getloadavg_initialized)
 648     {
 649       if (processor_set_default (host_self (), &default_set) == KERN_SUCCESS)
 650         getloadavg_initialized = true;
 651     }
 652
 653   if (getloadavg_initialized)
 654     {
 655       info_count = PROCESSOR_SET_BASIC_INFO_COUNT;
 656       if (processor_set_info (default_set, PROCESSOR_SET_BASIC_INFO, &host,
 657                               (processor_set_info_t) &info, &info_count)
 658           != KERN_SUCCESS)
 659         getloadavg_initialized = false;
 660       else
 661         {
 662           if (nelem > 0)
 663             loadavg[elem++] = (double) info.load_average / LOAD_SCALE;
 664         }
 665     }
 666
 667   if (!getloadavg_initialized)
 668     return -1;
 669 # endif /* NeXT */
 670
 671 # if !defined (LDAV_DONE) && defined (UMAX)
 672 #  define LDAV_DONE
 673 /* UMAX 4.2, which runs on the Encore Multimax multiprocessor, does not
 674    have a /dev/kmem.  Information about the workings of the running kernel
 675    can be gathered with inq_stats system calls.
 676    We only know how to get the 1-minute average for this system.  */
 677
 678   struct proc_summary proc_sum_data;
 679   struct stat_descr proc_info;
 680   double load;
 681   register unsigned int i, j;
 682
 683   if (cpus == 0)
 684     {
 685       register unsigned int c, i;
 686       struct cpu_config conf;
 687       struct stat_descr desc;
 688
 689       desc.sd_next = 0;
 690       desc.sd_subsys = SUBSYS_CPU;
 691       desc.sd_type = CPUTYPE_CONFIG;
 692       desc.sd_addr = (char *) &conf;
 693       desc.sd_size = sizeof conf;
 694
 695       if (inq_stats (1, &desc))
 696         return -1;
 697
 698       c = 0;
 699       for (i = 0; i < conf.config_maxclass; ++i)
 700         {
 701           struct class_stats stats;
 702           bzero ((char *) &stats, sizeof stats);
 703
 704           desc.sd_type = CPUTYPE_CLASS;
 705           desc.sd_objid = i;
 706           desc.sd_addr = (char *) &stats;
 707           desc.sd_size = sizeof stats;
 708
 709           if (inq_stats (1, &desc))
 710             return -1;
 711
 712           c += stats.class_numcpus;
 713         }
 714       cpus = c;
 715       samples = cpus < 2 ? 3 : (2 * cpus / 3);
 716     }
 717
 718   proc_info.sd_next = 0;
 719   proc_info.sd_subsys = SUBSYS_PROC;
 720   proc_info.sd_type = PROCTYPE_SUMMARY;
 721   proc_info.sd_addr = (char *) &proc_sum_data;
 722   proc_info.sd_size = sizeof (struct proc_summary);
 723   proc_info.sd_sizeused = 0;
 724
 725   if (inq_stats (1, &proc_info) != 0)
 726     return -1;
 727
 728   load = proc_sum_data.ps_nrunnable;
 729   j = 0;
 730   for (i = samples - 1; i > 0; --i)
 731     {
 732       load += proc_sum_data.ps_nrun[j];
 733       if (j++ == PS_NRUNSIZE)
 734         j = 0;
 735     }
 736
 737   if (nelem > 0)
 738     loadavg[elem++] = load / samples / cpus;
 739 # endif /* UMAX */
 740
 741 # if !defined (LDAV_DONE) && defined (DGUX)
 742 #  define LDAV_DONE
 743   /* This call can return -1 for an error, but with good args
 744      it's not supposed to fail.  The first argument is for no
 745      apparent reason of type `long int *'.  */
 746   dg_sys_info ((long int *) &load_info,
 747                DG_SYS_INFO_LOAD_INFO_TYPE,
 748                DG_SYS_INFO_LOAD_VERSION_0);
 749
 750   if (nelem > 0)
 751     loadavg[elem++] = load_info.one_minute;
 752   if (nelem > 1)
 753     loadavg[elem++] = load_info.five_minute;
 754   if (nelem > 2)
 755     loadavg[elem++] = load_info.fifteen_minute;
 756 # endif /* DGUX */
 757
 758 # if !defined (LDAV_DONE) && defined (apollo)
 759 #  define LDAV_DONE
 760 /* Apollo code from lisch@mentorg.com (Ray Lischner).
 761
 762    This system call is not documented.  The load average is obtained as
 763    three long integers, for the load average over the past minute,
 764    five minutes, and fifteen minutes.  Each value is a scaled integer,
 765    with 16 bits of integer part and 16 bits of fraction part.
 766
 767    I'm not sure which operating system first supported this system call,
 768    but I know that SR10.2 supports it.  */
 769
 770   extern void proc1_$get_loadav ();
 771   unsigned long load_ave[3];
 772
 773   proc1_$get_loadav (load_ave);
 774
 775   if (nelem > 0)
 776     loadavg[elem++] = load_ave[0] / 65536.0;
 777   if (nelem > 1)
 778     loadavg[elem++] = load_ave[1] / 65536.0;
 779   if (nelem > 2)
 780     loadavg[elem++] = load_ave[2] / 65536.0;
 781 # endif /* apollo */
 782
 783 # if !defined (LDAV_DONE) && defined (OSF_MIPS)
 784 #  define LDAV_DONE
 785
 786   struct tbl_loadavg load_ave;
 787   table (TBL_LOADAVG, 0, &load_ave, 1, sizeof (load_ave));
 788   loadavg[elem++]
 789     = (load_ave.tl_lscale == 0
 790        ? load_ave.tl_avenrun.d[0]
 791        : (load_ave.tl_avenrun.l[0] / (double) load_ave.tl_lscale));
 792 # endif /* OSF_MIPS */
 793
 794 # if !defined (LDAV_DONE) && (defined (__MSDOS__) || defined (WINDOWS32))
 795 #  define LDAV_DONE
 796
 797   /* A faithful emulation is going to have to be saved for a rainy day.  */
 798   for ( ; elem < nelem; elem++)
 799     {
 800       loadavg[elem] = 0.0;
 801     }
 802 # endif  /* __MSDOS__ || WINDOWS32 */
 803
 804 # if !defined (LDAV_DONE) && defined (OSF_ALPHA)
 805 #  define LDAV_DONE
 806
 807   struct tbl_loadavg load_ave;
 808   table (TBL_LOADAVG, 0, &load_ave, 1, sizeof (load_ave));
 809   for (elem = 0; elem < nelem; elem++)
 810     loadavg[elem]
 811       = (load_ave.tl_lscale == 0
 812          ? load_ave.tl_avenrun.d[elem]
 813          : (load_ave.tl_avenrun.l[elem] / (double) load_ave.tl_lscale));
 814 # endif /* OSF_ALPHA */
 815
 816 # if !defined (LDAV_DONE) && defined (VMS)
 817   /* VMS specific code -- read from the Load Ave driver.  */
 818
 819   LOAD_AVE_TYPE load_ave[3];
 820   static bool getloadavg_initialized;
 821 #  ifdef eunice
 822   struct
 823   {
 824     int dsc$w_length;
 825     char *dsc$a_pointer;
 826   } descriptor;
 827 #  endif
 828
 829   /* Ensure that there is a channel open to the load ave device.  */
 830   if (!getloadavg_initialized)
 831     {
 832       /* Attempt to open the channel.  */
 833 #  ifdef eunice
 834       descriptor.dsc$w_length = 18;
 835       descriptor.dsc$a_pointer = "$$VMS_LOAD_AVERAGE";
 836 #  else
 837       $DESCRIPTOR (descriptor, "LAV0:");
 838 #  endif
 839       if (sys$assign (&descriptor, &channel, 0, 0) & 1)
 840         getloadavg_initialized = true;
 841     }
 842
 843   /* Read the load average vector.  */
 844   if (getloadavg_initialized
 845       && !(sys$qiow (0, channel, IO$_READVBLK, 0, 0, 0,
 846                      load_ave, 12, 0, 0, 0, 0) & 1))
 847     {
 848       sys$dassgn (channel);
 849       getloadavg_initialized = false;
 850     }
 851
 852   if (!getloadavg_initialized)
 853     return -1;
 854 # endif /* VMS */
 855
 856 # if !defined (LDAV_DONE) && defined (LOAD_AVE_TYPE) && !defined (VMS)
 857
 858   /* UNIX-specific code -- read the average from /dev/kmem.  */
 859
 860 #  define LDAV_PRIVILEGED               /* This code requires special installation.  */
 861
 862   LOAD_AVE_TYPE load_ave[3];
 863
 864   /* Get the address of LDAV_SYMBOL.  */
 865   if (offset == 0)
 866     {
 867 #  ifndef sgi
 868 #   ifndef NLIST_STRUCT
 869       strcpy (nl[0].n_name, LDAV_SYMBOL);
 870       strcpy (nl[1].n_name, "");
 871 #   else /* NLIST_STRUCT */
 872 #    ifdef HAVE_STRUCT_NLIST_N_UN_N_NAME
 873       nl[0].n_un.n_name = LDAV_SYMBOL;
 874       nl[1].n_un.n_name = 0;
 875 #    else /* not HAVE_STRUCT_NLIST_N_UN_N_NAME */
 876       nl[0].n_name = LDAV_SYMBOL;
 877       nl[1].n_name = 0;
 878 #    endif /* not HAVE_STRUCT_NLIST_N_UN_N_NAME */
 879 #   endif /* NLIST_STRUCT */
 880
 881 #   ifndef SUNOS_5
 882       if (
 883 #    if !(defined (_AIX) && !defined (ps2))
 884           nlist (KERNEL_FILE, nl)
 885 #    else  /* _AIX */
 886           knlist (nl, 1, sizeof (nl[0]))
 887 #    endif
 888           >= 0)
 889           /* Omit "&& nl[0].n_type != 0 " -- it breaks on Sun386i.  */
 890           {
 891 #    ifdef FIXUP_KERNEL_SYMBOL_ADDR
 892             FIXUP_KERNEL_SYMBOL_ADDR (nl);
 893 #    endif
 894             offset = nl[0].n_value;
 895           }
 896 #   endif /* !SUNOS_5 */
 897 #  else  /* sgi */
 898       int ldav_off;
 899
 900       ldav_off = sysmp (MP_KERNADDR, MPKA_AVENRUN);
 901       if (ldav_off != -1)
 902         offset = (long int) ldav_off & 0x7fffffff;
 903 #  endif /* sgi */
 904     }
 905
 906   /* Make sure we have /dev/kmem open.  */
 907   if (!getloadavg_initialized)
 908     {
 909 #  ifndef SUNOS_5
 910       channel = open ("/dev/kmem", O_RDONLY);
 911       if (channel >= 0)
 912         {
 913           /* Set the channel to close on exec, so it does not
 914              litter any child's descriptor table.  */
 915           set_cloexec_flag (channel, true);
 916           getloadavg_initialized = true;
 917         }
 918 #  else /* SUNOS_5 */
 919       /* We pass 0 for the kernel, corefile, and swapfile names
 920          to use the currently running kernel.  */
 921       kd = kvm_open (0, 0, 0, O_RDONLY, 0);
 922       if (kd != 0)
 923         {
 924           /* nlist the currently running kernel.  */
 925           kvm_nlist (kd, nl);
 926           offset = nl[0].n_value;
 927           getloadavg_initialized = true;
 928         }
 929 #  endif /* SUNOS_5 */
 930     }
 931
 932   /* If we can, get the load average values.  */
 933   if (offset && getloadavg_initialized)
 934     {
 935       /* Try to read the load.  */
 936 #  ifndef SUNOS_5
 937       if (lseek (channel, offset, 0) == -1L
 938           || read (channel, (char *) load_ave, sizeof (load_ave))
 939           != sizeof (load_ave))
 940         {
 941           close (channel);
 942           getloadavg_initialized = false;
 943         }
 944 #  else  /* SUNOS_5 */
 945       if (kvm_read (kd, offset, (char *) load_ave, sizeof (load_ave))
 946           != sizeof (load_ave))
 947         {
 948           kvm_close (kd);
 949           getloadavg_initialized = false;
 950         }
 951 #  endif /* SUNOS_5 */
 952     }
 953
 954   if (offset == 0 || !getloadavg_initialized)
 955     return -1;
 956 # endif /* LOAD_AVE_TYPE and not VMS */
 957
 958 # if !defined (LDAV_DONE) && defined (LOAD_AVE_TYPE) /* Including VMS.  */
 959   if (nelem > 0)
 960     loadavg[elem++] = LDAV_CVT (load_ave[0]);
 961   if (nelem > 1)
 962     loadavg[elem++] = LDAV_CVT (load_ave[1]);
 963   if (nelem > 2)
 964     loadavg[elem++] = LDAV_CVT (load_ave[2]);
 965
 966 #  define LDAV_DONE
 967 # endif /* !LDAV_DONE && LOAD_AVE_TYPE */
 968
 969 # if !defined LDAV_DONE
 970   /* Set errno to zero to indicate that there was no particular error;
 971      this function just can't work at all on this system.  */
 972   errno = 0;
 973   elem = -1;
 974 # endif
 975   return elem;
 976 }
 977
 978 #endif /* ! HAVE_GETLOADAVG */
 979 \f
 980 #ifdef TEST
 981 int
 982 main (int argc, char **argv)
 983 {
 984   int naptime = 0;
 985
 986   if (argc > 1)
 987     naptime = atoi (argv[1]);
 988
 989   while (1)
 990     {
 991       double avg[3];
 992       int loads;
 993
 994       errno = 0;                /* Don't be misled if it doesn't set errno.  */
 995       loads = getloadavg (avg, 3);
 996       if (loads == -1)
 997         {
 998           perror ("Error getting load average");
 999           return EXIT_FAILURE;
1000         }
1001       if (loads > 0)
1002         printf ("1-minute: %f  ", avg[0]);
1003       if (loads > 1)
1004         printf ("5-minute: %f  ", avg[1]);
1005       if (loads > 2)
1006         printf ("15-minute: %f  ", avg[2]);
1007       if (loads > 0)
1008         putchar ('\n');
1009
1010       if (naptime == 0)
1011         break;
1012       sleep (naptime);
1013     }
1014
1015   return EXIT_SUCCESS;
1016 }
1017 #endif /* TEST */