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