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 # ifdef HAVE_UNISTD_H
 359 #  include <unistd.h>
 360 # endif
 361
 362 # include <stdio.h>
 363
 364 /* LOAD_AVE_TYPE should only get defined if we're going to use the
 365    nlist method.  */
 366 # if !defined(LOAD_AVE_TYPE) && (defined(BSD) || defined(LDAV_CVT) || defined(KERNEL_FILE) || defined(LDAV_SYMBOL))
 367 #  define LOAD_AVE_TYPE double
 368 # endif
 369
 370 # ifdef LOAD_AVE_TYPE
 371
 372 #  ifndef VMS
 373 #   ifndef __linux__
 374 #    ifndef NLIST_STRUCT
 375 #     include <a.out.h>
 376 #    else /* NLIST_STRUCT */
 377 #     include <nlist.h>
 378 #    endif /* NLIST_STRUCT */
 379
 380 #    ifdef SUNOS_5
 381 #     include <fcntl.h>
 382 #     include <kvm.h>
 383 #     include <kstat.h>
 384 #    endif
 385
 386 #    if defined (hpux) && defined (HAVE_PSTAT_GETDYNAMIC)
 387 #     include <sys/pstat.h>
 388 #    endif
 389
 390 #    ifndef KERNEL_FILE
 391 #     define KERNEL_FILE "/vmunix"
 392 #    endif /* KERNEL_FILE */
 393
 394 #    ifndef LDAV_SYMBOL
 395 #     define LDAV_SYMBOL "_avenrun"
 396 #    endif /* LDAV_SYMBOL */
 397 #   endif /* __linux__ */
 398
 399 #  else /* VMS */
 400
 401 #   ifndef eunice
 402 #    include <iodef.h>
 403 #    include <descrip.h>
 404 #   else /* eunice */
 405 #    include <vms/iodef.h>
 406 #   endif /* eunice */
 407 #  endif /* VMS */
 408
 409 #  ifndef LDAV_CVT
 410 #   define LDAV_CVT(n) ((double) (n))
 411 #  endif /* !LDAV_CVT */
 412
 413 # endif /* LOAD_AVE_TYPE */
 414
 415 # if defined(__GNU__) && !defined (NeXT)
 416 /* Note that NeXT Openstep defines __GNU__ even though it should not.  */
 417 /* GNU system acts much like NeXT, for load average purposes,
 418    but not exactly.  */
 419 #  define NeXT
 420 #  define host_self mach_host_self
 421 # endif
 422
 423 # ifdef NeXT
 424 #  ifdef HAVE_MACH_MACH_H
 425 #   include <mach/mach.h>
 426 #  else
 427 #   include <mach.h>
 428 #  endif
 429 # endif /* NeXT */
 430
 431 # ifdef sgi
 432 #  include <sys/sysmp.h>
 433 # endif /* sgi */
 434
 435 # ifdef UMAX
 436 #  include <stdio.h>
 437 #  include <signal.h>
 438 #  include <sys/time.h>
 439 #  include <sys/wait.h>
 440 #  include <sys/syscall.h>
 441
 442 #  ifdef UMAX_43
 443 #   include <machine/cpu.h>
 444 #   include <inq_stats/statistics.h>
 445 #   include <inq_stats/sysstats.h>
 446 #   include <inq_stats/cpustats.h>
 447 #   include <inq_stats/procstats.h>
 448 #  else /* Not UMAX_43.  */
 449 #   include <sys/sysdefs.h>
 450 #   include <sys/statistics.h>
 451 #   include <sys/sysstats.h>
 452 #   include <sys/cpudefs.h>
 453 #   include <sys/cpustats.h>
 454 #   include <sys/procstats.h>
 455 #  endif /* Not UMAX_43.  */
 456 # endif /* UMAX */
 457
 458 # ifdef DGUX
 459 #  include <sys/dg_sys_info.h>
 460 # endif
 461
 462 # if defined(HAVE_FCNTL_H) || defined(_POSIX_VERSION)
 463 #  include <fcntl.h>
 464 # else
 465 #  include <sys/file.h>
 466 # endif
 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 int 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 /* Nonzero if channel is valid.  */
 488 static int 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 /* Not VMS or sgi */
 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 (loadavg, nelem)
 509      double loadavg[];
 510      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 #   ifdef F_SETFD
 930 #    ifndef FD_CLOEXEC
 931 #     define FD_CLOEXEC 1
 932 #    endif
 933           (void) fcntl (channel, F_SETFD, FD_CLOEXEC);
 934 #   endif
 935           getloadavg_initialized = 1;
 936         }
 937 #  else /* SUNOS_5 */
 938       /* We pass 0 for the kernel, corefile, and swapfile names
 939          to use the currently running kernel.  */
 940       kd = kvm_open (0, 0, 0, O_RDONLY, 0);
 941       if (kd != 0)
 942         {
 943           /* nlist the currently running kernel.  */
 944           kvm_nlist (kd, nl);
 945           offset = nl[0].n_value;
 946           getloadavg_initialized = 1;
 947         }
 948 #  endif /* SUNOS_5 */
 949     }
 950
 951   /* If we can, get the load average values.  */
 952   if (offset && getloadavg_initialized)
 953     {
 954       /* Try to read the load.  */
 955 #  ifndef SUNOS_5
 956       if (lseek (channel, offset, 0) == -1L
 957           || read (channel, (char *) load_ave, sizeof (load_ave))
 958           != sizeof (load_ave))
 959         {
 960           close (channel);
 961           getloadavg_initialized = 0;
 962         }
 963 #  else  /* SUNOS_5 */
 964       if (kvm_read (kd, offset, (char *) load_ave, sizeof (load_ave))
 965           != sizeof (load_ave))
 966         {
 967           kvm_close (kd);
 968           getloadavg_initialized = 0;
 969         }
 970 #  endif /* SUNOS_5 */
 971     }
 972
 973   if (offset == 0 || !getloadavg_initialized)
 974     return -1;
 975 # endif /* LOAD_AVE_TYPE and not VMS */
 976
 977 # if !defined (LDAV_DONE) && defined (LOAD_AVE_TYPE) /* Including VMS.  */
 978   if (nelem > 0)
 979     loadavg[elem++] = LDAV_CVT (load_ave[0]);
 980   if (nelem > 1)
 981     loadavg[elem++] = LDAV_CVT (load_ave[1]);
 982   if (nelem > 2)
 983     loadavg[elem++] = LDAV_CVT (load_ave[2]);
 984
 985 #  define LDAV_DONE
 986 # endif /* !LDAV_DONE && LOAD_AVE_TYPE */
 987
 988 # ifdef LDAV_DONE
 989   return elem;
 990 # else
 991   /* Set errno to zero to indicate that there was no particular error;
 992      this function just can't work at all on this system.  */
 993   errno = 0;
 994   return -1;
 995 # endif
 996 }
 997
 998 #endif /* ! HAVE_GETLOADAVG */
 999 \f
1000 #ifdef TEST
1001 void
1002 main (argc, argv)
1003      int argc;
1004      char **argv;
1005 {
1006   int naptime = 0;
1007
1008   if (argc > 1)
1009     naptime = atoi (argv[1]);
1010
1011   while (1)
1012     {
1013       double avg[3];
1014       int loads;
1015
1016       errno = 0;                /* Don't be misled if it doesn't set errno.  */
1017       loads = getloadavg (avg, 3);
1018       if (loads == -1)
1019         {
1020           perror ("Error getting load average");
1021           exit (1);
1022         }
1023       if (loads > 0)
1024         printf ("1-minute: %f  ", avg[0]);
1025       if (loads > 1)
1026         printf ("5-minute: %f  ", avg[1]);
1027       if (loads > 2)
1028         printf ("15-minute: %f  ", avg[2]);
1029       if (loads > 0)
1030         putchar ('\n');
1031
1032       if (naptime == 0)
1033         break;
1034       sleep (naptime);
1035     }
1036
1037   exit (0);
1038 }
1039 #endif /* TEST */
1040
1041 /* arch-tag: 2b37a242-6289-41f4-8cd5-0e73fd615db1
1042    (do not change this comment) */