src/getloadavg.c

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