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