gl/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, 2005, 2006, 2007, 2008, 2009 Free
   5    Software Foundation, Inc.
   6
   7    NOTE: The canonical source of this file is maintained with gnulib.
   8    Bugs can be reported to bug-gnulib@gnu.org.
   9
  10    This program is free software: you can redistribute it and/or modify
  11    it under the terms of the GNU General Public License as published by
  12    the Free Software Foundation; either version 3 of the License, or
  13    (at your option) any later version.
  14
  15    This program is distributed in the hope that it will be useful,
  16    but WITHOUT ANY WARRANTY; without even the implied warranty of
  17    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18    GNU General Public License for more details.
  19
  20    You should have received a copy of the GNU General Public License
  21    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  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    HAVE_LIBPERFSTAT Define this if your system has the
  34                                 perfstat_cpu_total function in libperfstat (AIX).
  35    FIXUP_KERNEL_SYMBOL_ADDR()   Adjust address in returned struct nlist.
  36    KERNEL_FILE                  Name of the kernel file to nlist.
  37    LDAV_CVT()                   Scale the load average from the kernel.
  38                                 Returns a double.
  39    LDAV_SYMBOL                  Name of kernel symbol giving load average.
  40    LOAD_AVE_TYPE                Type of the load average array in the kernel.
  41                                 Must be defined unless one of
  42                                 apollo, DGUX, NeXT, or UMAX is defined;
  43                                 or we have libkstat;
  44                                 otherwise, no load average is available.
  45    HAVE_NLIST_H                 nlist.h is available.  NLIST_STRUCT defaults
  46                                 to this.
  47    NLIST_STRUCT                 Include nlist.h, not a.out.h, and
  48                                 the nlist n_name element is a pointer,
  49                                 not an array.
  50    HAVE_STRUCT_NLIST_N_UN_N_NAME `n_un.n_name' is member of `struct nlist'.
  51    LINUX_LDAV_FILE              [__linux__, __CYGWIN__]: File containing
  52                                 load averages.
  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 file system mounted.
  74                                 Support from Michael K. Johnson.
  75    __CYGWIN__                   Cygwin emulates linux /proc/loadavg.
  76    __NetBSD__                   NetBSD: assumes /kern file system mounted.
  77
  78    In addition, to avoid nesting many #ifdefs, we internally set
  79    LDAV_DONE to indicate that the load average has been computed.
  80
  81    We also #define LDAV_PRIVILEGED if a program will require
  82    special installation to be able to call getloadavg.  */
  83
  84 /* "configure" defines CONFIGURING_GETLOADAVG to sidestep problems
  85    with partially-configured source directories.  */
  86
  87 #ifndef CONFIGURING_GETLOADAVG
  88 # include <config.h>
  89 # include <stdbool.h>
  90 #endif
  91
  92 /* Specification.  */
  93 #include <stdlib.h>
  94
  95 #include <errno.h>
  96 #include <stdio.h>
  97
  98 /* Exclude all the code except the test program at the end
  99    if the system has its own `getloadavg' function.  */
 100
 101 #ifndef HAVE_GETLOADAVG
 102
 103 # include <sys/types.h>
 104
 105 /* Both the Emacs and non-Emacs sections want this.  Some
 106    configuration files' definitions for the LOAD_AVE_CVT macro (like
 107    sparc.h's) use macros like FSCALE, defined here.  */
 108 # if defined (unix) || defined (__unix)
 109 #  include <sys/param.h>
 110 # endif
 111
 112 # include "c-strtod.h"
 113 # include "cloexec.h"
 114 # include "intprops.h"
 115 # include "xalloc.h"
 116
 117 /* The existing Emacs configuration files define a macro called
 118    LOAD_AVE_CVT, which accepts a value of type LOAD_AVE_TYPE, and
 119    returns the load average multiplied by 100.  What we actually want
 120    is a macro called LDAV_CVT, which returns the load average as an
 121    unmultiplied double.
 122
 123    For backwards compatibility, we'll define LDAV_CVT in terms of
 124    LOAD_AVE_CVT, but future machine config files should just define
 125    LDAV_CVT directly.  */
 126
 127 # if !defined (LDAV_CVT) && defined (LOAD_AVE_CVT)
 128 #  define LDAV_CVT(n) (LOAD_AVE_CVT (n) / 100.0)
 129 # endif
 130
 131 # if !defined (BSD) && defined (ultrix)
 132 /* Ultrix behaves like BSD on Vaxen.  */
 133 #  define BSD
 134 # endif
 135
 136 # ifdef NeXT
 137 /* NeXT in the 2.{0,1,2} releases defines BSD in <sys/param.h>, which
 138    conflicts with the definition understood in this file, that this
 139    really is BSD. */
 140 #  undef BSD
 141
 142 /* NeXT defines FSCALE in <sys/param.h>.  However, we take FSCALE being
 143    defined to mean that the nlist method should be used, which is not true.  */
 144 #  undef FSCALE
 145 # endif
 146
 147 /* Same issues as for NeXT apply to the HURD-based GNU system.  */
 148 # ifdef __GNU__
 149 #  undef BSD
 150 #  undef FSCALE
 151 # endif /* __GNU__ */
 152
 153 /* Set values that are different from the defaults, which are
 154    set a little farther down with #ifndef.  */
 155
 156
 157 /* Some shorthands.  */
 158
 159 # if defined (HPUX) && !defined (hpux)
 160 #  define hpux
 161 # endif
 162
 163 # if defined (__hpux) && !defined (hpux)
 164 #  define hpux
 165 # endif
 166
 167 # if defined (__sun) && !defined (sun)
 168 #  define sun
 169 # endif
 170
 171 # if defined (hp300) && !defined (hpux)
 172 #  define MORE_BSD
 173 # endif
 174
 175 # if defined (ultrix) && defined (mips)
 176 #  define decstation
 177 # endif
 178
 179 # if defined (__SVR4) && !defined (SVR4)
 180 #  define SVR4
 181 # endif
 182
 183 # if (defined (sun) && defined (SVR4)) || defined (SOLARIS2)
 184 #  define SUNOS_5
 185 # endif
 186
 187 # if defined (__osf__) && (defined (__alpha) || defined (__alpha__))
 188 #  define OSF_ALPHA
 189 #  include <sys/mbuf.h>
 190 #  include <sys/socket.h>
 191 #  include <net/route.h>
 192 #  include <sys/table.h>
 193 /* Tru64 4.0D's table.h redefines sys */
 194 #  undef sys
 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 #  if defined _AIX && ! defined HAVE_LIBPERFSTAT
 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 #  if defined _AIX && !defined HAVE_LIBPERFSTAT
 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) && !defined(HAVE_LIBPERFSTAT)))
 355 #  define LDAV_SYMBOL "avenrun"
 356 # endif
 357
 358 # include <unistd.h>
 359
 360 /* LOAD_AVE_TYPE should only get defined if we're going to use the
 361    nlist method.  */
 362 # if !defined (LOAD_AVE_TYPE) && (defined (BSD) || defined (LDAV_CVT) || defined (KERNEL_FILE) || defined (LDAV_SYMBOL))
 363 #  define LOAD_AVE_TYPE double
 364 # endif
 365
 366 # ifdef LOAD_AVE_TYPE
 367
 368 #  ifndef __VMS
 369 #   ifndef __linux__
 370 #    ifndef NLIST_STRUCT
 371 #     include <a.out.h>
 372 #    else /* NLIST_STRUCT */
 373 #     include <nlist.h>
 374 #    endif /* NLIST_STRUCT */
 375
 376 #    ifdef SUNOS_5
 377 #     include <fcntl.h>
 378 #     include <kvm.h>
 379 #     include <kstat.h>
 380 #    endif
 381
 382 #    if defined (hpux) && defined (HAVE_PSTAT_GETDYNAMIC)
 383 #     include <sys/pstat.h>
 384 #    endif
 385
 386 #    ifndef KERNEL_FILE
 387 #     define KERNEL_FILE "/vmunix"
 388 #    endif /* KERNEL_FILE */
 389
 390 #    ifndef LDAV_SYMBOL
 391 #     define LDAV_SYMBOL "_avenrun"
 392 #    endif /* LDAV_SYMBOL */
 393 #   endif /* __linux__ */
 394
 395 #  else /* __VMS */
 396
 397 #   ifndef eunice
 398 #    include <iodef.h>
 399 #    include <descrip.h>
 400 #   else /* eunice */
 401 #    include <vms/iodef.h>
 402 #   endif /* eunice */
 403 #  endif /* __VMS */
 404
 405 #  ifndef LDAV_CVT
 406 #   define LDAV_CVT(n) ((double) (n))
 407 #  endif /* !LDAV_CVT */
 408
 409 # endif /* LOAD_AVE_TYPE */
 410
 411 # if defined HAVE_LIBPERFSTAT
 412 #  include <sys/protosw.h>
 413 #  include <libperfstat.h>
 414 #  include <sys/proc.h>
 415 #  ifndef SBITS
 416 #   define SBITS 16
 417 #  endif
 418 # endif
 419
 420 # if defined (__GNU__) && !defined (NeXT)
 421 /* Note that NeXT Openstep defines __GNU__ even though it should not.  */
 422 /* GNU system acts much like NeXT, for load average purposes,
 423    but not exactly.  */
 424 #  define NeXT
 425 #  define host_self mach_host_self
 426 # endif
 427
 428 # ifdef NeXT
 429 #  ifdef HAVE_MACH_MACH_H
 430 #   include <mach/mach.h>
 431 #  else
 432 #   include <mach.h>
 433 #  endif
 434 # endif /* NeXT */
 435
 436 # ifdef sgi
 437 #  include <sys/sysmp.h>
 438 # endif /* sgi */
 439
 440 # ifdef UMAX
 441 #  include <signal.h>
 442 #  include <sys/time.h>
 443 #  include <sys/wait.h>
 444 #  include <sys/syscall.h>
 445
 446 #  ifdef UMAX_43
 447 #   include <machine/cpu.h>
 448 #   include <inq_stats/statistics.h>
 449 #   include <inq_stats/sysstats.h>
 450 #   include <inq_stats/cpustats.h>
 451 #   include <inq_stats/procstats.h>
 452 #  else /* Not UMAX_43.  */
 453 #   include <sys/sysdefs.h>
 454 #   include <sys/statistics.h>
 455 #   include <sys/sysstats.h>
 456 #   include <sys/cpudefs.h>
 457 #   include <sys/cpustats.h>
 458 #   include <sys/procstats.h>
 459 #  endif /* Not UMAX_43.  */
 460 # endif /* UMAX */
 461
 462 # ifdef DGUX
 463 #  include <sys/dg_sys_info.h>
 464 # endif
 465
 466 # include "fcntl--.h"
 467 \f
 468 /* Avoid static vars inside a function since in HPUX they dump as pure.  */
 469
 470 # ifdef NeXT
 471 static processor_set_t default_set;
 472 static bool getloadavg_initialized;
 473 # endif /* NeXT */
 474
 475 # ifdef UMAX
 476 static unsigned int cpus = 0;
 477 static unsigned int samples;
 478 # endif /* UMAX */
 479
 480 # ifdef DGUX
 481 static struct dg_sys_info_load_info load_info;  /* what-a-mouthful! */
 482 # endif /* DGUX */
 483
 484 # if !defined (HAVE_LIBKSTAT) && defined (LOAD_AVE_TYPE)
 485 /* File descriptor open to /dev/kmem or VMS load ave driver.  */
 486 static int channel;
 487 /* True iff channel is valid.  */
 488 static bool getloadavg_initialized;
 489 /* Offset in kmem to seek to read load average, or 0 means invalid.  */
 490 static long offset;
 491
 492 #  if ! defined __VMS && ! defined sgi && ! defined __linux__
 493 static struct nlist nl[2];
 494 #  endif
 495
 496 #  ifdef SUNOS_5
 497 static kvm_t *kd;
 498 #  endif /* SUNOS_5 */
 499
 500 # endif /* LOAD_AVE_TYPE && !HAVE_LIBKSTAT */
 501 \f
 502 /* Put the 1 minute, 5 minute and 15 minute load averages
 503    into the first NELEM elements of LOADAVG.
 504    Return the number written (never more than 3, but may be less than NELEM),
 505    or -1 if an error occurred.  */
 506
 507 int
 508 getloadavg (double loadavg[], int nelem)
 509 {
 510   int elem = 0;                 /* Return value.  */
 511
 512 # ifdef NO_GET_LOAD_AVG
 513 #  define LDAV_DONE
 514   /* Set errno to zero to indicate that there was no particular error;
 515      this function just can't work at all on this system.  */
 516   errno = 0;
 517   elem = -1;
 518 # endif
 519
 520 # if !defined (LDAV_DONE) && defined (HAVE_LIBKSTAT)
 521 /* Use libkstat because we don't have to be root.  */
 522 #  define LDAV_DONE
 523   kstat_ctl_t *kc;
 524   kstat_t *ksp;
 525   kstat_named_t *kn;
 526
 527   kc = kstat_open ();
 528   if (kc == 0)
 529     return -1;
 530   ksp = kstat_lookup (kc, "unix", 0, "system_misc");
 531   if (ksp == 0)
 532     return -1;
 533   if (kstat_read (kc, ksp, 0) == -1)
 534     return -1;
 535
 536
 537   kn = kstat_data_lookup (ksp, "avenrun_1min");
 538   if (kn == 0)
 539     {
 540       /* Return -1 if no load average information is available.  */
 541       nelem = 0;
 542       elem = -1;
 543     }
 544
 545   if (nelem >= 1)
 546     loadavg[elem++] = (double) kn->value.ul / FSCALE;
 547
 548   if (nelem >= 2)
 549     {
 550       kn = kstat_data_lookup (ksp, "avenrun_5min");
 551       if (kn != 0)
 552         {
 553           loadavg[elem++] = (double) kn->value.ul / FSCALE;
 554
 555           if (nelem >= 3)
 556             {
 557               kn = kstat_data_lookup (ksp, "avenrun_15min");
 558               if (kn != 0)
 559                 loadavg[elem++] = (double) kn->value.ul / FSCALE;
 560             }
 561         }
 562     }
 563
 564   kstat_close (kc);
 565 # endif /* HAVE_LIBKSTAT */
 566
 567 # if !defined (LDAV_DONE) && defined (hpux) && defined (HAVE_PSTAT_GETDYNAMIC)
 568 /* Use pstat_getdynamic() because we don't have to be root.  */
 569 #  define LDAV_DONE
 570 #  undef LOAD_AVE_TYPE
 571
 572   struct pst_dynamic dyn_info;
 573   if (pstat_getdynamic (&dyn_info, sizeof (dyn_info), 0, 0) < 0)
 574     return -1;
 575   if (nelem > 0)
 576     loadavg[elem++] = dyn_info.psd_avg_1_min;
 577   if (nelem > 1)
 578     loadavg[elem++] = dyn_info.psd_avg_5_min;
 579   if (nelem > 2)
 580     loadavg[elem++] = dyn_info.psd_avg_15_min;
 581
 582 # endif /* hpux && HAVE_PSTAT_GETDYNAMIC */
 583
 584 # if ! defined LDAV_DONE && defined HAVE_LIBPERFSTAT
 585 #  define LDAV_DONE
 586 #  undef LOAD_AVE_TYPE
 587 /* Use perfstat_cpu_total because we don't have to be root. */
 588   {
 589     perfstat_cpu_total_t cpu_stats;
 590     int result = perfstat_cpu_total (NULL, &cpu_stats, sizeof cpu_stats, 1);
 591     if (result == -1)
 592       return result;
 593     loadavg[0] = cpu_stats.loadavg[0] / (double)(1 << SBITS);
 594     loadavg[1] = cpu_stats.loadavg[1] / (double)(1 << SBITS);
 595     loadavg[2] = cpu_stats.loadavg[2] / (double)(1 << SBITS);
 596     elem = 3;
 597   }
 598 # endif
 599
 600 # if !defined (LDAV_DONE) && (defined (__linux__) || defined (__CYGWIN__))
 601 #  define LDAV_DONE
 602 #  undef LOAD_AVE_TYPE
 603
 604 #  ifndef LINUX_LDAV_FILE
 605 #   define LINUX_LDAV_FILE "/proc/loadavg"
 606 #  endif
 607
 608   char ldavgbuf[3 * (INT_STRLEN_BOUND (int) + sizeof ".00 ")];
 609   char const *ptr = ldavgbuf;
 610   int fd, count;
 611
 612   fd = open (LINUX_LDAV_FILE, O_RDONLY);
 613   if (fd == -1)
 614     return -1;
 615   count = read (fd, ldavgbuf, sizeof ldavgbuf - 1);
 616   (void) close (fd);
 617   if (count <= 0)
 618     return -1;
 619   ldavgbuf[count] = '\0';
 620
 621   for (elem = 0; elem < nelem; elem++)
 622     {
 623       char *endptr;
 624       double d;
 625
 626       errno = 0;
 627       d = c_strtod (ptr, &endptr);
 628       if (ptr == endptr || (d == 0 && errno != 0))
 629         {
 630           if (elem == 0)
 631             return -1;
 632           break;
 633         }
 634       loadavg[elem] = d;
 635       ptr = endptr;
 636     }
 637
 638   return elem;
 639
 640 # endif /* __linux__ || __CYGWIN__ */
 641
 642 # if !defined (LDAV_DONE) && defined (__NetBSD__)
 643 #  define LDAV_DONE
 644 #  undef LOAD_AVE_TYPE
 645
 646 #  ifndef NETBSD_LDAV_FILE
 647 #   define NETBSD_LDAV_FILE "/kern/loadavg"
 648 #  endif
 649
 650   unsigned long int load_ave[3], scale;
 651   int count;
 652   FILE *fp;
 653
 654   fp = fopen (NETBSD_LDAV_FILE, "r");
 655   if (fp == NULL)
 656     return -1;
 657   count = fscanf (fp, "%lu %lu %lu %lu\n",
 658                   &load_ave[0], &load_ave[1], &load_ave[2],
 659                   &scale);
 660   (void) fclose (fp);
 661   if (count != 4)
 662     return -1;
 663
 664   for (elem = 0; elem < nelem; elem++)
 665     loadavg[elem] = (double) load_ave[elem] / (double) scale;
 666
 667   return elem;
 668
 669 # endif /* __NetBSD__ */
 670
 671 # if !defined (LDAV_DONE) && defined (NeXT)
 672 #  define LDAV_DONE
 673   /* The NeXT code was adapted from iscreen 3.2.  */
 674
 675   host_t host;
 676   struct processor_set_basic_info info;
 677   unsigned int info_count;
 678
 679   /* We only know how to get the 1-minute average for this system,
 680      so even if the caller asks for more than 1, we only return 1.  */
 681
 682   if (!getloadavg_initialized)
 683     {
 684       if (processor_set_default (host_self (), &default_set) == KERN_SUCCESS)
 685         getloadavg_initialized = true;
 686     }
 687
 688   if (getloadavg_initialized)
 689     {
 690       info_count = PROCESSOR_SET_BASIC_INFO_COUNT;
 691       if (processor_set_info (default_set, PROCESSOR_SET_BASIC_INFO, &host,
 692                               (processor_set_info_t) &info, &info_count)
 693           != KERN_SUCCESS)
 694         getloadavg_initialized = false;
 695       else
 696         {
 697           if (nelem > 0)
 698             loadavg[elem++] = (double) info.load_average / LOAD_SCALE;
 699         }
 700     }
 701
 702   if (!getloadavg_initialized)
 703     return -1;
 704 # endif /* NeXT */
 705
 706 # if !defined (LDAV_DONE) && defined (UMAX)
 707 #  define LDAV_DONE
 708 /* UMAX 4.2, which runs on the Encore Multimax multiprocessor, does not
 709    have a /dev/kmem.  Information about the workings of the running kernel
 710    can be gathered with inq_stats system calls.
 711    We only know how to get the 1-minute average for this system.  */
 712
 713   struct proc_summary proc_sum_data;
 714   struct stat_descr proc_info;
 715   double load;
 716   register unsigned int i, j;
 717
 718   if (cpus == 0)
 719     {
 720       register unsigned int c, i;
 721       struct cpu_config conf;
 722       struct stat_descr desc;
 723
 724       desc.sd_next = 0;
 725       desc.sd_subsys = SUBSYS_CPU;
 726       desc.sd_type = CPUTYPE_CONFIG;
 727       desc.sd_addr = (char *) &conf;
 728       desc.sd_size = sizeof conf;
 729
 730       if (inq_stats (1, &desc))
 731         return -1;
 732
 733       c = 0;
 734       for (i = 0; i < conf.config_maxclass; ++i)
 735         {
 736           struct class_stats stats;
 737           bzero ((char *) &stats, sizeof stats);
 738
 739           desc.sd_type = CPUTYPE_CLASS;
 740           desc.sd_objid = i;
 741           desc.sd_addr = (char *) &stats;
 742           desc.sd_size = sizeof stats;
 743
 744           if (inq_stats (1, &desc))
 745             return -1;
 746
 747           c += stats.class_numcpus;
 748         }
 749       cpus = c;
 750       samples = cpus < 2 ? 3 : (2 * cpus / 3);
 751     }
 752
 753   proc_info.sd_next = 0;
 754   proc_info.sd_subsys = SUBSYS_PROC;
 755   proc_info.sd_type = PROCTYPE_SUMMARY;
 756   proc_info.sd_addr = (char *) &proc_sum_data;
 757   proc_info.sd_size = sizeof (struct proc_summary);
 758   proc_info.sd_sizeused = 0;
 759
 760   if (inq_stats (1, &proc_info) != 0)
 761     return -1;
 762
 763   load = proc_sum_data.ps_nrunnable;
 764   j = 0;
 765   for (i = samples - 1; i > 0; --i)
 766     {
 767       load += proc_sum_data.ps_nrun[j];
 768       if (j++ == PS_NRUNSIZE)
 769         j = 0;
 770     }
 771
 772   if (nelem > 0)
 773     loadavg[elem++] = load / samples / cpus;
 774 # endif /* UMAX */
 775
 776 # if !defined (LDAV_DONE) && defined (DGUX)
 777 #  define LDAV_DONE
 778   /* This call can return -1 for an error, but with good args
 779      it's not supposed to fail.  The first argument is for no
 780      apparent reason of type `long int *'.  */
 781   dg_sys_info ((long int *) &load_info,
 782                DG_SYS_INFO_LOAD_INFO_TYPE,
 783                DG_SYS_INFO_LOAD_VERSION_0);
 784
 785   if (nelem > 0)
 786     loadavg[elem++] = load_info.one_minute;
 787   if (nelem > 1)
 788     loadavg[elem++] = load_info.five_minute;
 789   if (nelem > 2)
 790     loadavg[elem++] = load_info.fifteen_minute;
 791 # endif /* DGUX */
 792
 793 # if !defined (LDAV_DONE) && defined (apollo)
 794 #  define LDAV_DONE
 795 /* Apollo code from lisch@mentorg.com (Ray Lischner).
 796
 797    This system call is not documented.  The load average is obtained as
 798    three long integers, for the load average over the past minute,
 799    five minutes, and fifteen minutes.  Each value is a scaled integer,
 800    with 16 bits of integer part and 16 bits of fraction part.
 801
 802    I'm not sure which operating system first supported this system call,
 803    but I know that SR10.2 supports it.  */
 804
 805   extern void proc1_$get_loadav ();
 806   unsigned long load_ave[3];
 807
 808   proc1_$get_loadav (load_ave);
 809
 810   if (nelem > 0)
 811     loadavg[elem++] = load_ave[0] / 65536.0;
 812   if (nelem > 1)
 813     loadavg[elem++] = load_ave[1] / 65536.0;
 814   if (nelem > 2)
 815     loadavg[elem++] = load_ave[2] / 65536.0;
 816 # endif /* apollo */
 817
 818 # if !defined (LDAV_DONE) && defined (OSF_MIPS)
 819 #  define LDAV_DONE
 820
 821   struct tbl_loadavg load_ave;
 822   table (TBL_LOADAVG, 0, &load_ave, 1, sizeof (load_ave));
 823   loadavg[elem++]
 824     = (load_ave.tl_lscale == 0
 825        ? load_ave.tl_avenrun.d[0]
 826        : (load_ave.tl_avenrun.l[0] / (double) load_ave.tl_lscale));
 827 # endif /* OSF_MIPS */
 828
 829 # if !defined (LDAV_DONE) && (defined (__MSDOS__) || defined (WINDOWS32))
 830 #  define LDAV_DONE
 831
 832   /* A faithful emulation is going to have to be saved for a rainy day.  */
 833   for ( ; elem < nelem; elem++)
 834     {
 835       loadavg[elem] = 0.0;
 836     }
 837 # endif  /* __MSDOS__ || WINDOWS32 */
 838
 839 # if !defined (LDAV_DONE) && defined (OSF_ALPHA)
 840 #  define LDAV_DONE
 841
 842   struct tbl_loadavg load_ave;
 843   table (TBL_LOADAVG, 0, &load_ave, 1, sizeof (load_ave));
 844   for (elem = 0; elem < nelem; elem++)
 845     loadavg[elem]
 846       = (load_ave.tl_lscale == 0
 847          ? load_ave.tl_avenrun.d[elem]
 848          : (load_ave.tl_avenrun.l[elem] / (double) load_ave.tl_lscale));
 849 # endif /* OSF_ALPHA */
 850
 851 # if ! defined LDAV_DONE && defined __VMS
 852   /* VMS specific code -- read from the Load Ave driver.  */
 853
 854   LOAD_AVE_TYPE load_ave[3];
 855   static bool getloadavg_initialized;
 856 #  ifdef eunice
 857   struct
 858   {
 859     int dsc$w_length;
 860     char *dsc$a_pointer;
 861   } descriptor;
 862 #  endif
 863
 864   /* Ensure that there is a channel open to the load ave device.  */
 865   if (!getloadavg_initialized)
 866     {
 867       /* Attempt to open the channel.  */
 868 #  ifdef eunice
 869       descriptor.dsc$w_length = 18;
 870       descriptor.dsc$a_pointer = "$$VMS_LOAD_AVERAGE";
 871 #  else
 872       $DESCRIPTOR (descriptor, "LAV0:");
 873 #  endif
 874       if (sys$assign (&descriptor, &channel, 0, 0) & 1)
 875         getloadavg_initialized = true;
 876     }
 877
 878   /* Read the load average vector.  */
 879   if (getloadavg_initialized
 880       && !(sys$qiow (0, channel, IO$_READVBLK, 0, 0, 0,
 881                      load_ave, 12, 0, 0, 0, 0) & 1))
 882     {
 883       sys$dassgn (channel);
 884       getloadavg_initialized = false;
 885     }
 886
 887   if (!getloadavg_initialized)
 888     return -1;
 889 # endif /* ! defined LDAV_DONE && defined __VMS */
 890
 891 # if ! defined LDAV_DONE && defined LOAD_AVE_TYPE && ! defined __VMS
 892
 893   /* UNIX-specific code -- read the average from /dev/kmem.  */
 894
 895 #  define LDAV_PRIVILEGED               /* This code requires special installation.  */
 896
 897   LOAD_AVE_TYPE load_ave[3];
 898
 899   /* Get the address of LDAV_SYMBOL.  */
 900   if (offset == 0)
 901     {
 902 #  ifndef sgi
 903 #   ifndef NLIST_STRUCT
 904       strcpy (nl[0].n_name, LDAV_SYMBOL);
 905       strcpy (nl[1].n_name, "");
 906 #   else /* NLIST_STRUCT */
 907 #    ifdef HAVE_STRUCT_NLIST_N_UN_N_NAME
 908       nl[0].n_un.n_name = LDAV_SYMBOL;
 909       nl[1].n_un.n_name = 0;
 910 #    else /* not HAVE_STRUCT_NLIST_N_UN_N_NAME */
 911       nl[0].n_name = LDAV_SYMBOL;
 912       nl[1].n_name = 0;
 913 #    endif /* not HAVE_STRUCT_NLIST_N_UN_N_NAME */
 914 #   endif /* NLIST_STRUCT */
 915
 916 #   ifndef SUNOS_5
 917       if (
 918 #    if !(defined (_AIX) && !defined (ps2))
 919           nlist (KERNEL_FILE, nl)
 920 #    else  /* _AIX */
 921           knlist (nl, 1, sizeof (nl[0]))
 922 #    endif
 923           >= 0)
 924           /* Omit "&& nl[0].n_type != 0 " -- it breaks on Sun386i.  */
 925           {
 926 #    ifdef FIXUP_KERNEL_SYMBOL_ADDR
 927             FIXUP_KERNEL_SYMBOL_ADDR (nl);
 928 #    endif
 929             offset = nl[0].n_value;
 930           }
 931 #   endif /* !SUNOS_5 */
 932 #  else  /* sgi */
 933       int ldav_off;
 934
 935       ldav_off = sysmp (MP_KERNADDR, MPKA_AVENRUN);
 936       if (ldav_off != -1)
 937         offset = (long int) ldav_off & 0x7fffffff;
 938 #  endif /* sgi */
 939     }
 940
 941   /* Make sure we have /dev/kmem open.  */
 942   if (!getloadavg_initialized)
 943     {
 944 #  ifndef SUNOS_5
 945       channel = open ("/dev/kmem", O_RDONLY);
 946       if (channel >= 0)
 947         {
 948           /* Set the channel to close on exec, so it does not
 949              litter any child's descriptor table.  */
 950           set_cloexec_flag (channel, true);
 951           getloadavg_initialized = true;
 952         }
 953 #  else /* SUNOS_5 */
 954       /* We pass 0 for the kernel, corefile, and swapfile names
 955          to use the currently running kernel.  */
 956       kd = kvm_open (0, 0, 0, O_RDONLY, 0);
 957       if (kd != 0)
 958         {
 959           /* nlist the currently running kernel.  */
 960           kvm_nlist (kd, nl);
 961           offset = nl[0].n_value;
 962           getloadavg_initialized = true;
 963         }
 964 #  endif /* SUNOS_5 */
 965     }
 966
 967   /* If we can, get the load average values.  */
 968   if (offset && getloadavg_initialized)
 969     {
 970       /* Try to read the load.  */
 971 #  ifndef SUNOS_5
 972       if (lseek (channel, offset, 0) == -1L
 973           || read (channel, (char *) load_ave, sizeof (load_ave))
 974           != sizeof (load_ave))
 975         {
 976           close (channel);
 977           getloadavg_initialized = false;
 978         }
 979 #  else  /* SUNOS_5 */
 980       if (kvm_read (kd, offset, (char *) load_ave, sizeof (load_ave))
 981           != sizeof (load_ave))
 982         {
 983           kvm_close (kd);
 984           getloadavg_initialized = false;
 985         }
 986 #  endif /* SUNOS_5 */
 987     }
 988
 989   if (offset == 0 || !getloadavg_initialized)
 990     return -1;
 991 # endif /* ! defined LDAV_DONE && defined LOAD_AVE_TYPE && ! defined __VMS */
 992
 993 # if !defined (LDAV_DONE) && defined (LOAD_AVE_TYPE) /* Including VMS.  */
 994   if (nelem > 0)
 995     loadavg[elem++] = LDAV_CVT (load_ave[0]);
 996   if (nelem > 1)
 997     loadavg[elem++] = LDAV_CVT (load_ave[1]);
 998   if (nelem > 2)
 999     loadavg[elem++] = LDAV_CVT (load_ave[2]);
1000
1001 #  define LDAV_DONE
1002 # endif /* !LDAV_DONE && LOAD_AVE_TYPE */
1003
1004 # if !defined LDAV_DONE
1005   /* Set errno to zero to indicate that there was no particular error;
1006      this function just can't work at all on this system.  */
1007   errno = 0;
1008   elem = -1;
1009 # endif
1010   return elem;
1011 }
1012
1013 #endif /* ! HAVE_GETLOADAVG */
1014 \f
1015 #ifdef TEST
1016 int
1017 main (int argc, char **argv)
1018 {
1019   int naptime = 0;
1020
1021   if (argc > 1)
1022     naptime = atoi (argv[1]);
1023
1024   while (1)
1025     {
1026       double avg[3];
1027       int loads;
1028
1029       errno = 0;                /* Don't be misled if it doesn't set errno.  */
1030       loads = getloadavg (avg, 3);
1031       if (loads == -1)
1032         {
1033           perror ("Error getting load average");
1034           return EXIT_FAILURE;
1035         }
1036       if (loads > 0)
1037         printf ("1-minute: %f  ", avg[0]);
1038       if (loads > 1)
1039         printf ("5-minute: %f  ", avg[1]);
1040       if (loads > 2)
1041         printf ("15-minute: %f  ", avg[2]);
1042       if (loads > 0)
1043         putchar ('\n');
1044
1045       if (naptime == 0)
1046         break;
1047       sleep (naptime);
1048     }
1049
1050   return EXIT_SUCCESS;
1051 }
1052 #endif /* TEST */