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