lib/getloadavg.c

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