Code

Sync with gnulib
[nagiosplug.git] / gl / getloadavg.c
1 /* Get the system load averages.
3    Copyright (C) 1985, 1986, 1987, 1988, 1989, 1991, 1992, 1993, 1994,
4    1995, 1997, 1999, 2000, 2003, 2004, 2005, 2006, 2007, 2008 Free Software
5    Foundation, Inc.
7    NOTE: The canonical source of this file is maintained with gnulib.
8    Bugs can be reported to bug-gnulib@gnu.org.
10    This program is free software: you can redistribute it and/or modify
11    it under the terms of the GNU General Public License as published by
12    the Free Software Foundation; either version 3 of the License, or
13    (at your option) any later version.
15    This program is distributed in the hope that it will be useful,
16    but WITHOUT ANY WARRANTY; without even the implied warranty of
17    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
18    GNU General Public License for more details.
20    You should have received a copy of the GNU General Public License
21    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
23 /* Compile-time symbols that this file uses:
25    HAVE_PSTAT_GETDYNAMIC        Define this if your system has the
26                                 pstat_getdynamic function.  I think it
27                                 is unique to HPUX9.  The best way to get the
28                                 definition is through the AC_FUNC_GETLOADAVG
29                                 macro that comes with autoconf 2.13 or newer.
30                                 If that isn't an option, then just put
31                                 AC_CHECK_FUNCS(pstat_getdynamic) in your
32                                 configure.in file.
33    HAVE_LIBPERFSTAT Define this if your system has the
34                                 perfstat_cpu_total function in libperfstat (AIX).
35    FIXUP_KERNEL_SYMBOL_ADDR()   Adjust address in returned struct nlist.
36    KERNEL_FILE                  Name of the kernel file to nlist.
37    LDAV_CVT()                   Scale the load average from the kernel.
38                                 Returns a double.
39    LDAV_SYMBOL                  Name of kernel symbol giving load average.
40    LOAD_AVE_TYPE                Type of the load average array in the kernel.
41                                 Must be defined unless one of
42                                 apollo, DGUX, NeXT, or UMAX is defined;
43                                 or we have libkstat;
44                                 otherwise, no load average is available.
45    HAVE_NLIST_H                 nlist.h is available.  NLIST_STRUCT defaults
46                                 to this.
47    NLIST_STRUCT                 Include nlist.h, not a.out.h, and
48                                 the nlist n_name element is a pointer,
49                                 not an array.
50    HAVE_STRUCT_NLIST_N_UN_N_NAME `n_un.n_name' is member of `struct nlist'.
51    LINUX_LDAV_FILE              [__linux__, __CYGWIN__]: File containing
52                                 load averages.
54    Specific system predefines this file uses, aside from setting
55    default values if not emacs:
57    apollo
58    BSD                          Real BSD, not just BSD-like.
59    convex
60    DGUX
61    eunice                       UNIX emulator under VMS.
62    hpux
63    __MSDOS__                    No-op for MSDOS.
64    NeXT
65    sgi
66    sequent                      Sequent Dynix 3.x.x (BSD)
67    _SEQUENT_                    Sequent DYNIX/ptx 1.x.x (SYSV)
68    sony_news                    NEWS-OS (works at least for 4.1C)
69    UMAX
70    UMAX4_3
71    VMS
72    WINDOWS32                    No-op for Windows95/NT.
73    __linux__                    Linux: assumes /proc file system mounted.
74                                 Support from Michael K. Johnson.
75    __CYGWIN__                   Cygwin emulates linux /proc/loadavg.
76    __NetBSD__                   NetBSD: assumes /kern file system mounted.
78    In addition, to avoid nesting many #ifdefs, we internally set
79    LDAV_DONE to indicate that the load average has been computed.
81    We also #define LDAV_PRIVILEGED if a program will require
82    special installation to be able to call getloadavg.  */
84 /* "configure" defines CONFIGURING_GETLOADAVG to sidestep problems
85    with partially-configured source directories.  */
87 #ifndef CONFIGURING_GETLOADAVG
88 # include <config.h>
89 # include <stdbool.h>
90 #endif
92 /* Specification.  */
93 #include <stdlib.h>
95 #include <errno.h>
96 #include <stdio.h>
98 /* Exclude all the code except the test program at the end
99    if the system has its own `getloadavg' function.  */
101 #ifndef HAVE_GETLOADAVG
103 # include <sys/types.h>
105 /* Both the Emacs and non-Emacs sections want this.  Some
106    configuration files' definitions for the LOAD_AVE_CVT macro (like
107    sparc.h's) use macros like FSCALE, defined here.  */
108 # if defined (unix) || defined (__unix)
109 #  include <sys/param.h>
110 # endif
112 # include "c-strtod.h"
113 # include "cloexec.h"
114 # include "intprops.h"
115 # include "xalloc.h"
117 /* The existing Emacs configuration files define a macro called
118    LOAD_AVE_CVT, which accepts a value of type LOAD_AVE_TYPE, and
119    returns the load average multiplied by 100.  What we actually want
120    is a macro called LDAV_CVT, which returns the load average as an
121    unmultiplied double.
123    For backwards compatibility, we'll define LDAV_CVT in terms of
124    LOAD_AVE_CVT, but future machine config files should just define
125    LDAV_CVT directly.  */
127 # if !defined (LDAV_CVT) && defined (LOAD_AVE_CVT)
128 #  define LDAV_CVT(n) (LOAD_AVE_CVT (n) / 100.0)
129 # endif
131 # if !defined (BSD) && defined (ultrix)
132 /* Ultrix behaves like BSD on Vaxen.  */
133 #  define BSD
134 # endif
136 # ifdef NeXT
137 /* NeXT in the 2.{0,1,2} releases defines BSD in <sys/param.h>, which
138    conflicts with the definition understood in this file, that this
139    really is BSD. */
140 #  undef BSD
142 /* NeXT defines FSCALE in <sys/param.h>.  However, we take FSCALE being
143    defined to mean that the nlist method should be used, which is not true.  */
144 #  undef FSCALE
145 # endif
147 /* Same issues as for NeXT apply to the HURD-based GNU system.  */
148 # ifdef __GNU__
149 #  undef BSD
150 #  undef FSCALE
151 # endif /* __GNU__ */
153 /* Set values that are different from the defaults, which are
154    set a little farther down with #ifndef.  */
157 /* Some shorthands.  */
159 # if defined (HPUX) && !defined (hpux)
160 #  define hpux
161 # endif
163 # if defined (__hpux) && !defined (hpux)
164 #  define hpux
165 # endif
167 # if defined (__sun) && !defined (sun)
168 #  define sun
169 # endif
171 # if defined (hp300) && !defined (hpux)
172 #  define MORE_BSD
173 # endif
175 # if defined (ultrix) && defined (mips)
176 #  define decstation
177 # endif
179 # if defined (__SVR4) && !defined (SVR4)
180 #  define SVR4
181 # endif
183 # if (defined (sun) && defined (SVR4)) || defined (SOLARIS2)
184 #  define SUNOS_5
185 # endif
187 # if defined (__osf__) && (defined (__alpha) || defined (__alpha__))
188 #  define OSF_ALPHA
189 #  include <sys/mbuf.h>
190 #  include <sys/socket.h>
191 #  include <net/route.h>
192 #  include <sys/table.h>
193 /* Tru64 4.0D's table.h redefines sys */
194 #  undef sys
195 # endif
197 # if defined (__osf__) && (defined (mips) || defined (__mips__))
198 #  define OSF_MIPS
199 #  include <sys/table.h>
200 # endif
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
210 /* VAX C can't handle multi-line #ifs, or lines longer than 256 chars.  */
211 # ifndef LOAD_AVE_TYPE
213 #  ifdef MORE_BSD
214 #   define LOAD_AVE_TYPE long
215 #  endif
217 #  ifdef sun
218 #   define LOAD_AVE_TYPE long
219 #  endif
221 #  ifdef decstation
222 #   define LOAD_AVE_TYPE long
223 #  endif
225 #  ifdef _SEQUENT_
226 #   define LOAD_AVE_TYPE long
227 #  endif
229 #  ifdef sgi
230 #   define LOAD_AVE_TYPE long
231 #  endif
233 #  ifdef SVR4
234 #   define LOAD_AVE_TYPE long
235 #  endif
237 #  ifdef sony_news
238 #   define LOAD_AVE_TYPE long
239 #  endif
241 #  ifdef sequent
242 #   define LOAD_AVE_TYPE long
243 #  endif
245 #  ifdef OSF_ALPHA
246 #   define LOAD_AVE_TYPE long
247 #  endif
249 #  if defined (ardent) && defined (titan)
250 #   define LOAD_AVE_TYPE long
251 #  endif
253 #  ifdef tek4300
254 #   define LOAD_AVE_TYPE long
255 #  endif
257 #  if defined (alliant) && defined (i860) /* Alliant FX/2800 */
258 #   define LOAD_AVE_TYPE long
259 #  endif
261 #  if defined _AIX && ! defined HAVE_LIBPERFSTAT
262 #   define LOAD_AVE_TYPE long
263 #  endif
265 #  ifdef convex
266 #   define LOAD_AVE_TYPE double
267 #   ifndef LDAV_CVT
268 #    define LDAV_CVT(n) (n)
269 #   endif
270 #  endif
272 # endif /* No LOAD_AVE_TYPE.  */
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
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
289 # ifndef FSCALE
291 /* SunOS and some others define FSCALE in sys/param.h.  */
293 #  ifdef MORE_BSD
294 #   define FSCALE 2048.0
295 #  endif
297 #  if defined (MIPS) || defined (SVR4) || defined (decstation)
298 #   define FSCALE 256
299 #  endif
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
308 #  if defined (ardent) && defined (titan)
309 #   define FSCALE 65536.0
310 #  endif
312 #  ifdef tek4300
313 #   define FSCALE 100.0
314 #  endif
316 #  if defined _AIX && !defined HAVE_LIBPERFSTAT
317 #   define FSCALE 65536.0
318 #  endif
320 # endif /* Not FSCALE.  */
322 # if !defined (LDAV_CVT) && defined (FSCALE)
323 #  define LDAV_CVT(n) (((double) (n)) / FSCALE)
324 # endif
326 # ifndef NLIST_STRUCT
327 #  if HAVE_NLIST_H
328 #   define NLIST_STRUCT
329 #  endif
330 # endif
332 # if defined (sgi) || (defined (mips) && !defined (BSD))
333 #  define FIXUP_KERNEL_SYMBOL_ADDR(nl) ((nl)[0].n_value &= ~(1 << 31))
334 # endif
337 # if !defined (KERNEL_FILE) && defined (sequent)
338 #  define KERNEL_FILE "/dynix"
339 # endif
341 # if !defined (KERNEL_FILE) && defined (hpux)
342 #  define KERNEL_FILE "/hp-ux"
343 # endif
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
350 # if !defined (LDAV_SYMBOL) && defined (alliant)
351 #  define LDAV_SYMBOL "_Loadavg"
352 # endif
354 # if !defined (LDAV_SYMBOL) && ((defined (hpux) && !defined (hp9000s300)) || defined (_SEQUENT_) || defined (SVR4) || defined (ISC) || defined (sgi) || (defined (ardent) && defined (titan)) || (defined (_AIX) && !defined(HAVE_LIBPERFSTAT)))
355 #  define LDAV_SYMBOL "avenrun"
356 # endif
358 # include <unistd.h>
360 /* LOAD_AVE_TYPE should only get defined if we're going to use the
361    nlist method.  */
362 # if !defined (LOAD_AVE_TYPE) && (defined (BSD) || defined (LDAV_CVT) || defined (KERNEL_FILE) || defined (LDAV_SYMBOL))
363 #  define LOAD_AVE_TYPE double
364 # endif
366 # ifdef LOAD_AVE_TYPE
368 #  ifndef __VMS
369 #   ifndef __linux__
370 #    ifndef NLIST_STRUCT
371 #     include <a.out.h>
372 #    else /* NLIST_STRUCT */
373 #     include <nlist.h>
374 #    endif /* NLIST_STRUCT */
376 #    ifdef SUNOS_5
377 #     include <fcntl.h>
378 #     include <kvm.h>
379 #     include <kstat.h>
380 #    endif
382 #    if defined (hpux) && defined (HAVE_PSTAT_GETDYNAMIC)
383 #     include <sys/pstat.h>
384 #    endif
386 #    ifndef KERNEL_FILE
387 #     define KERNEL_FILE "/vmunix"
388 #    endif /* KERNEL_FILE */
390 #    ifndef LDAV_SYMBOL
391 #     define LDAV_SYMBOL "_avenrun"
392 #    endif /* LDAV_SYMBOL */
393 #   endif /* __linux__ */
395 #  else /* __VMS */
397 #   ifndef eunice
398 #    include <iodef.h>
399 #    include <descrip.h>
400 #   else /* eunice */
401 #    include <vms/iodef.h>
402 #   endif /* eunice */
403 #  endif /* __VMS */
405 #  ifndef LDAV_CVT
406 #   define LDAV_CVT(n) ((double) (n))
407 #  endif /* !LDAV_CVT */
409 # endif /* LOAD_AVE_TYPE */
411 # if defined HAVE_LIBPERFSTAT
412 #  include <sys/protosw.h>
413 #  include <libperfstat.h>
414 #  include <sys/proc.h>
415 #  ifndef SBITS
416 #   define SBITS 16
417 #  endif
418 # endif
420 # if defined (__GNU__) && !defined (NeXT)
421 /* Note that NeXT Openstep defines __GNU__ even though it should not.  */
422 /* GNU system acts much like NeXT, for load average purposes,
423    but not exactly.  */
424 #  define NeXT
425 #  define host_self mach_host_self
426 # endif
428 # ifdef NeXT
429 #  ifdef HAVE_MACH_MACH_H
430 #   include <mach/mach.h>
431 #  else
432 #   include <mach.h>
433 #  endif
434 # endif /* NeXT */
436 # ifdef sgi
437 #  include <sys/sysmp.h>
438 # endif /* sgi */
440 # ifdef UMAX
441 #  include <signal.h>
442 #  include <sys/time.h>
443 #  include <sys/wait.h>
444 #  include <sys/syscall.h>
446 #  ifdef UMAX_43
447 #   include <machine/cpu.h>
448 #   include <inq_stats/statistics.h>
449 #   include <inq_stats/sysstats.h>
450 #   include <inq_stats/cpustats.h>
451 #   include <inq_stats/procstats.h>
452 #  else /* Not UMAX_43.  */
453 #   include <sys/sysdefs.h>
454 #   include <sys/statistics.h>
455 #   include <sys/sysstats.h>
456 #   include <sys/cpudefs.h>
457 #   include <sys/cpustats.h>
458 #   include <sys/procstats.h>
459 #  endif /* Not UMAX_43.  */
460 # endif /* UMAX */
462 # ifdef DGUX
463 #  include <sys/dg_sys_info.h>
464 # endif
466 # include "fcntl--.h"
467 \f
468 /* Avoid static vars inside a function since in HPUX they dump as pure.  */
470 # ifdef NeXT
471 static processor_set_t default_set;
472 static bool getloadavg_initialized;
473 # endif /* NeXT */
475 # ifdef UMAX
476 static unsigned int cpus = 0;
477 static unsigned int samples;
478 # endif /* UMAX */
480 # ifdef DGUX
481 static struct dg_sys_info_load_info load_info;  /* what-a-mouthful! */
482 # endif /* DGUX */
484 # if !defined (HAVE_LIBKSTAT) && defined (LOAD_AVE_TYPE)
485 /* File descriptor open to /dev/kmem or VMS load ave driver.  */
486 static int channel;
487 /* True iff channel is valid.  */
488 static bool getloadavg_initialized;
489 /* Offset in kmem to seek to read load average, or 0 means invalid.  */
490 static long offset;
492 #  if ! defined __VMS && ! defined sgi && ! defined __linux__
493 static struct nlist nl[2];
494 #  endif
496 #  ifdef SUNOS_5
497 static kvm_t *kd;
498 #  endif /* SUNOS_5 */
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.  */
507 int
508 getloadavg (double loadavg[], int nelem)
510   int elem = 0;                 /* Return value.  */
512 # ifdef NO_GET_LOAD_AVG
513 #  define LDAV_DONE
514   /* Set errno to zero to indicate that there was no particular error;
515      this function just can't work at all on this system.  */
516   errno = 0;
517   elem = -1;
518 # endif
520 # if !defined (LDAV_DONE) && defined (HAVE_LIBKSTAT)
521 /* Use libkstat because we don't have to be root.  */
522 #  define LDAV_DONE
523   kstat_ctl_t *kc;
524   kstat_t *ksp;
525   kstat_named_t *kn;
527   kc = kstat_open ();
528   if (kc == 0)
529     return -1;
530   ksp = kstat_lookup (kc, "unix", 0, "system_misc");
531   if (ksp == 0)
532     return -1;
533   if (kstat_read (kc, ksp, 0) == -1)
534     return -1;
537   kn = kstat_data_lookup (ksp, "avenrun_1min");
538   if (kn == 0)
539     {
540       /* Return -1 if no load average information is available.  */
541       nelem = 0;
542       elem = -1;
543     }
545   if (nelem >= 1)
546     loadavg[elem++] = (double) kn->value.ul / FSCALE;
548   if (nelem >= 2)
549     {
550       kn = kstat_data_lookup (ksp, "avenrun_5min");
551       if (kn != 0)
552         {
553           loadavg[elem++] = (double) kn->value.ul / FSCALE;
555           if (nelem >= 3)
556             {
557               kn = kstat_data_lookup (ksp, "avenrun_15min");
558               if (kn != 0)
559                 loadavg[elem++] = (double) kn->value.ul / FSCALE;
560             }
561         }
562     }
564   kstat_close (kc);
565 # endif /* HAVE_LIBKSTAT */
567 # if !defined (LDAV_DONE) && defined (hpux) && defined (HAVE_PSTAT_GETDYNAMIC)
568 /* Use pstat_getdynamic() because we don't have to be root.  */
569 #  define LDAV_DONE
570 #  undef LOAD_AVE_TYPE
572   struct pst_dynamic dyn_info;
573   if (pstat_getdynamic (&dyn_info, sizeof (dyn_info), 0, 0) < 0)
574     return -1;
575   if (nelem > 0)
576     loadavg[elem++] = dyn_info.psd_avg_1_min;
577   if (nelem > 1)
578     loadavg[elem++] = dyn_info.psd_avg_5_min;
579   if (nelem > 2)
580     loadavg[elem++] = dyn_info.psd_avg_15_min;
582 # endif /* hpux && HAVE_PSTAT_GETDYNAMIC */
584 # if ! defined LDAV_DONE && defined HAVE_LIBPERFSTAT
585 #  define LDAV_DONE
586 #  undef LOAD_AVE_TYPE
587 /* Use perfstat_cpu_total because we don't have to be root. */
588   {
589     perfstat_cpu_total_t cpu_stats;
590     int result = perfstat_cpu_total (NULL, &cpu_stats, sizeof cpu_stats, 1);
591     if (result == -1)
592       return result;
593     loadavg[0] = cpu_stats.loadavg[0] / (double)(1 << SBITS);
594     loadavg[1] = cpu_stats.loadavg[1] / (double)(1 << SBITS);
595     loadavg[2] = cpu_stats.loadavg[2] / (double)(1 << SBITS);
596     elem = 3;
597   }
598 # endif
600 # if !defined (LDAV_DONE) && (defined (__linux__) || defined (__CYGWIN__))
601 #  define LDAV_DONE
602 #  undef LOAD_AVE_TYPE
604 #  ifndef LINUX_LDAV_FILE
605 #   define LINUX_LDAV_FILE "/proc/loadavg"
606 #  endif
608   char ldavgbuf[3 * (INT_STRLEN_BOUND (int) + sizeof ".00 ")];
609   char const *ptr = ldavgbuf;
610   int fd, count;
612   fd = open (LINUX_LDAV_FILE, O_RDONLY);
613   if (fd == -1)
614     return -1;
615   count = read (fd, ldavgbuf, sizeof ldavgbuf - 1);
616   (void) close (fd);
617   if (count <= 0)
618     return -1;
619   ldavgbuf[count] = '\0';
621   for (elem = 0; elem < nelem; elem++)
622     {
623       char *endptr;
624       double d = c_strtod (ptr, &endptr);
625       if (ptr == endptr)
626         {
627           if (elem == 0)
628             return -1;
629           break;
630         }
631       loadavg[elem] = d;
632       ptr = endptr;
633     }
635   return elem;
637 # endif /* __linux__ || __CYGWIN__ */
639 # if !defined (LDAV_DONE) && defined (__NetBSD__)
640 #  define LDAV_DONE
641 #  undef LOAD_AVE_TYPE
643 #  ifndef NETBSD_LDAV_FILE
644 #   define NETBSD_LDAV_FILE "/kern/loadavg"
645 #  endif
647   unsigned long int load_ave[3], scale;
648   int count;
649   FILE *fp;
651   fp = fopen (NETBSD_LDAV_FILE, "r");
652   if (fp == NULL)
653     return -1;
654   count = fscanf (fp, "%lu %lu %lu %lu\n",
655                   &load_ave[0], &load_ave[1], &load_ave[2],
656                   &scale);
657   (void) fclose (fp);
658   if (count != 4)
659     return -1;
661   for (elem = 0; elem < nelem; elem++)
662     loadavg[elem] = (double) load_ave[elem] / (double) scale;
664   return elem;
666 # endif /* __NetBSD__ */
668 # if !defined (LDAV_DONE) && defined (NeXT)
669 #  define LDAV_DONE
670   /* The NeXT code was adapted from iscreen 3.2.  */
672   host_t host;
673   struct processor_set_basic_info info;
674   unsigned int info_count;
676   /* We only know how to get the 1-minute average for this system,
677      so even if the caller asks for more than 1, we only return 1.  */
679   if (!getloadavg_initialized)
680     {
681       if (processor_set_default (host_self (), &default_set) == KERN_SUCCESS)
682         getloadavg_initialized = true;
683     }
685   if (getloadavg_initialized)
686     {
687       info_count = PROCESSOR_SET_BASIC_INFO_COUNT;
688       if (processor_set_info (default_set, PROCESSOR_SET_BASIC_INFO, &host,
689                               (processor_set_info_t) &info, &info_count)
690           != KERN_SUCCESS)
691         getloadavg_initialized = false;
692       else
693         {
694           if (nelem > 0)
695             loadavg[elem++] = (double) info.load_average / LOAD_SCALE;
696         }
697     }
699   if (!getloadavg_initialized)
700     return -1;
701 # endif /* NeXT */
703 # if !defined (LDAV_DONE) && defined (UMAX)
704 #  define LDAV_DONE
705 /* UMAX 4.2, which runs on the Encore Multimax multiprocessor, does not
706    have a /dev/kmem.  Information about the workings of the running kernel
707    can be gathered with inq_stats system calls.
708    We only know how to get the 1-minute average for this system.  */
710   struct proc_summary proc_sum_data;
711   struct stat_descr proc_info;
712   double load;
713   register unsigned int i, j;
715   if (cpus == 0)
716     {
717       register unsigned int c, i;
718       struct cpu_config conf;
719       struct stat_descr desc;
721       desc.sd_next = 0;
722       desc.sd_subsys = SUBSYS_CPU;
723       desc.sd_type = CPUTYPE_CONFIG;
724       desc.sd_addr = (char *) &conf;
725       desc.sd_size = sizeof conf;
727       if (inq_stats (1, &desc))
728         return -1;
730       c = 0;
731       for (i = 0; i < conf.config_maxclass; ++i)
732         {
733           struct class_stats stats;
734           bzero ((char *) &stats, sizeof stats);
736           desc.sd_type = CPUTYPE_CLASS;
737           desc.sd_objid = i;
738           desc.sd_addr = (char *) &stats;
739           desc.sd_size = sizeof stats;
741           if (inq_stats (1, &desc))
742             return -1;
744           c += stats.class_numcpus;
745         }
746       cpus = c;
747       samples = cpus < 2 ? 3 : (2 * cpus / 3);
748     }
750   proc_info.sd_next = 0;
751   proc_info.sd_subsys = SUBSYS_PROC;
752   proc_info.sd_type = PROCTYPE_SUMMARY;
753   proc_info.sd_addr = (char *) &proc_sum_data;
754   proc_info.sd_size = sizeof (struct proc_summary);
755   proc_info.sd_sizeused = 0;
757   if (inq_stats (1, &proc_info) != 0)
758     return -1;
760   load = proc_sum_data.ps_nrunnable;
761   j = 0;
762   for (i = samples - 1; i > 0; --i)
763     {
764       load += proc_sum_data.ps_nrun[j];
765       if (j++ == PS_NRUNSIZE)
766         j = 0;
767     }
769   if (nelem > 0)
770     loadavg[elem++] = load / samples / cpus;
771 # endif /* UMAX */
773 # if !defined (LDAV_DONE) && defined (DGUX)
774 #  define LDAV_DONE
775   /* This call can return -1 for an error, but with good args
776      it's not supposed to fail.  The first argument is for no
777      apparent reason of type `long int *'.  */
778   dg_sys_info ((long int *) &load_info,
779                DG_SYS_INFO_LOAD_INFO_TYPE,
780                DG_SYS_INFO_LOAD_VERSION_0);
782   if (nelem > 0)
783     loadavg[elem++] = load_info.one_minute;
784   if (nelem > 1)
785     loadavg[elem++] = load_info.five_minute;
786   if (nelem > 2)
787     loadavg[elem++] = load_info.fifteen_minute;
788 # endif /* DGUX */
790 # if !defined (LDAV_DONE) && defined (apollo)
791 #  define LDAV_DONE
792 /* Apollo code from lisch@mentorg.com (Ray Lischner).
794    This system call is not documented.  The load average is obtained as
795    three long integers, for the load average over the past minute,
796    five minutes, and fifteen minutes.  Each value is a scaled integer,
797    with 16 bits of integer part and 16 bits of fraction part.
799    I'm not sure which operating system first supported this system call,
800    but I know that SR10.2 supports it.  */
802   extern void proc1_$get_loadav ();
803   unsigned long load_ave[3];
805   proc1_$get_loadav (load_ave);
807   if (nelem > 0)
808     loadavg[elem++] = load_ave[0] / 65536.0;
809   if (nelem > 1)
810     loadavg[elem++] = load_ave[1] / 65536.0;
811   if (nelem > 2)
812     loadavg[elem++] = load_ave[2] / 65536.0;
813 # endif /* apollo */
815 # if !defined (LDAV_DONE) && defined (OSF_MIPS)
816 #  define LDAV_DONE
818   struct tbl_loadavg load_ave;
819   table (TBL_LOADAVG, 0, &load_ave, 1, sizeof (load_ave));
820   loadavg[elem++]
821     = (load_ave.tl_lscale == 0
822        ? load_ave.tl_avenrun.d[0]
823        : (load_ave.tl_avenrun.l[0] / (double) load_ave.tl_lscale));
824 # endif /* OSF_MIPS */
826 # if !defined (LDAV_DONE) && (defined (__MSDOS__) || defined (WINDOWS32))
827 #  define LDAV_DONE
829   /* A faithful emulation is going to have to be saved for a rainy day.  */
830   for ( ; elem < nelem; elem++)
831     {
832       loadavg[elem] = 0.0;
833     }
834 # endif  /* __MSDOS__ || WINDOWS32 */
836 # if !defined (LDAV_DONE) && defined (OSF_ALPHA)
837 #  define LDAV_DONE
839   struct tbl_loadavg load_ave;
840   table (TBL_LOADAVG, 0, &load_ave, 1, sizeof (load_ave));
841   for (elem = 0; elem < nelem; elem++)
842     loadavg[elem]
843       = (load_ave.tl_lscale == 0
844          ? load_ave.tl_avenrun.d[elem]
845          : (load_ave.tl_avenrun.l[elem] / (double) load_ave.tl_lscale));
846 # endif /* OSF_ALPHA */
848 # if ! defined LDAV_DONE && defined __VMS
849   /* VMS specific code -- read from the Load Ave driver.  */
851   LOAD_AVE_TYPE load_ave[3];
852   static bool getloadavg_initialized;
853 #  ifdef eunice
854   struct
855   {
856     int dsc$w_length;
857     char *dsc$a_pointer;
858   } descriptor;
859 #  endif
861   /* Ensure that there is a channel open to the load ave device.  */
862   if (!getloadavg_initialized)
863     {
864       /* Attempt to open the channel.  */
865 #  ifdef eunice
866       descriptor.dsc$w_length = 18;
867       descriptor.dsc$a_pointer = "$$VMS_LOAD_AVERAGE";
868 #  else
869       $DESCRIPTOR (descriptor, "LAV0:");
870 #  endif
871       if (sys$assign (&descriptor, &channel, 0, 0) & 1)
872         getloadavg_initialized = true;
873     }
875   /* Read the load average vector.  */
876   if (getloadavg_initialized
877       && !(sys$qiow (0, channel, IO$_READVBLK, 0, 0, 0,
878                      load_ave, 12, 0, 0, 0, 0) & 1))
879     {
880       sys$dassgn (channel);
881       getloadavg_initialized = false;
882     }
884   if (!getloadavg_initialized)
885     return -1;
886 # endif /* ! defined LDAV_DONE && defined __VMS */
888 # if ! defined LDAV_DONE && defined LOAD_AVE_TYPE && ! defined __VMS
890   /* UNIX-specific code -- read the average from /dev/kmem.  */
892 #  define LDAV_PRIVILEGED               /* This code requires special installation.  */
894   LOAD_AVE_TYPE load_ave[3];
896   /* Get the address of LDAV_SYMBOL.  */
897   if (offset == 0)
898     {
899 #  ifndef sgi
900 #   ifndef NLIST_STRUCT
901       strcpy (nl[0].n_name, LDAV_SYMBOL);
902       strcpy (nl[1].n_name, "");
903 #   else /* NLIST_STRUCT */
904 #    ifdef HAVE_STRUCT_NLIST_N_UN_N_NAME
905       nl[0].n_un.n_name = LDAV_SYMBOL;
906       nl[1].n_un.n_name = 0;
907 #    else /* not HAVE_STRUCT_NLIST_N_UN_N_NAME */
908       nl[0].n_name = LDAV_SYMBOL;
909       nl[1].n_name = 0;
910 #    endif /* not HAVE_STRUCT_NLIST_N_UN_N_NAME */
911 #   endif /* NLIST_STRUCT */
913 #   ifndef SUNOS_5
914       if (
915 #    if !(defined (_AIX) && !defined (ps2))
916           nlist (KERNEL_FILE, nl)
917 #    else  /* _AIX */
918           knlist (nl, 1, sizeof (nl[0]))
919 #    endif
920           >= 0)
921           /* Omit "&& nl[0].n_type != 0 " -- it breaks on Sun386i.  */
922           {
923 #    ifdef FIXUP_KERNEL_SYMBOL_ADDR
924             FIXUP_KERNEL_SYMBOL_ADDR (nl);
925 #    endif
926             offset = nl[0].n_value;
927           }
928 #   endif /* !SUNOS_5 */
929 #  else  /* sgi */
930       int ldav_off;
932       ldav_off = sysmp (MP_KERNADDR, MPKA_AVENRUN);
933       if (ldav_off != -1)
934         offset = (long int) ldav_off & 0x7fffffff;
935 #  endif /* sgi */
936     }
938   /* Make sure we have /dev/kmem open.  */
939   if (!getloadavg_initialized)
940     {
941 #  ifndef SUNOS_5
942       channel = open ("/dev/kmem", O_RDONLY);
943       if (channel >= 0)
944         {
945           /* Set the channel to close on exec, so it does not
946              litter any child's descriptor table.  */
947           set_cloexec_flag (channel, true);
948           getloadavg_initialized = true;
949         }
950 #  else /* SUNOS_5 */
951       /* We pass 0 for the kernel, corefile, and swapfile names
952          to use the currently running kernel.  */
953       kd = kvm_open (0, 0, 0, O_RDONLY, 0);
954       if (kd != 0)
955         {
956           /* nlist the currently running kernel.  */
957           kvm_nlist (kd, nl);
958           offset = nl[0].n_value;
959           getloadavg_initialized = true;
960         }
961 #  endif /* SUNOS_5 */
962     }
964   /* If we can, get the load average values.  */
965   if (offset && getloadavg_initialized)
966     {
967       /* Try to read the load.  */
968 #  ifndef SUNOS_5
969       if (lseek (channel, offset, 0) == -1L
970           || read (channel, (char *) load_ave, sizeof (load_ave))
971           != sizeof (load_ave))
972         {
973           close (channel);
974           getloadavg_initialized = false;
975         }
976 #  else  /* SUNOS_5 */
977       if (kvm_read (kd, offset, (char *) load_ave, sizeof (load_ave))
978           != sizeof (load_ave))
979         {
980           kvm_close (kd);
981           getloadavg_initialized = false;
982         }
983 #  endif /* SUNOS_5 */
984     }
986   if (offset == 0 || !getloadavg_initialized)
987     return -1;
988 # endif /* ! defined LDAV_DONE && defined LOAD_AVE_TYPE && ! defined __VMS */
990 # if !defined (LDAV_DONE) && defined (LOAD_AVE_TYPE) /* Including VMS.  */
991   if (nelem > 0)
992     loadavg[elem++] = LDAV_CVT (load_ave[0]);
993   if (nelem > 1)
994     loadavg[elem++] = LDAV_CVT (load_ave[1]);
995   if (nelem > 2)
996     loadavg[elem++] = LDAV_CVT (load_ave[2]);
998 #  define LDAV_DONE
999 # endif /* !LDAV_DONE && LOAD_AVE_TYPE */
1001 # if !defined LDAV_DONE
1002   /* Set errno to zero to indicate that there was no particular error;
1003      this function just can't work at all on this system.  */
1004   errno = 0;
1005   elem = -1;
1006 # endif
1007   return elem;
1010 #endif /* ! HAVE_GETLOADAVG */
1011 \f
1012 #ifdef TEST
1013 int
1014 main (int argc, char **argv)
1016   int naptime = 0;
1018   if (argc > 1)
1019     naptime = atoi (argv[1]);
1021   while (1)
1022     {
1023       double avg[3];
1024       int loads;
1026       errno = 0;                /* Don't be misled if it doesn't set errno.  */
1027       loads = getloadavg (avg, 3);
1028       if (loads == -1)
1029         {
1030           perror ("Error getting load average");
1031           return EXIT_FAILURE;
1032         }
1033       if (loads > 0)
1034         printf ("1-minute: %f  ", avg[0]);
1035       if (loads > 1)
1036         printf ("5-minute: %f  ", avg[1]);
1037       if (loads > 2)
1038         printf ("15-minute: %f  ", avg[2]);
1039       if (loads > 0)
1040         putchar ('\n');
1042       if (naptime == 0)
1043         break;
1044       sleep (naptime);
1045     }
1047   return EXIT_SUCCESS;
1049 #endif /* TEST */