src/getloadavg.c

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