lib/getloadavg.c

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