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)
509 {
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;
1008 }
1010 #endif /* ! HAVE_GETLOADAVG */
1011 \f
1012 #ifdef TEST
1013 int
1014 main (int argc, char **argv)
1015 {
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;
1048 }
1049 #endif /* TEST */