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