src/getloadavg.c

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