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