blob: 0908cbe1902c2e6f0988d03a51dcf80fd7e5e80b [file] [log] [blame]
/*
* Copyright (C) Tildeslash Ltd. All rights reserved.
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU Affero General Public License version 3.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU Affero General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*
* In addition, as a special exception, the copyright holders give
* permission to link the code of portions of this program with the
* OpenSSL library under certain conditions as described in each
* individual source file, and distribute linked combinations
* including the two.
*
* You must obey the GNU Affero General Public License in all respects
* for all of the code used other than OpenSSL.
*/
#include "config.h"
#include "monit.h"
#ifdef HAVE_STDIO_H
#include <stdio.h>
#endif
#ifdef HAVE_ERRNO_H
#include <errno.h>
#endif
#ifdef HAVE_UNISTD_H
#include <unistd.h>
#endif
#ifdef HAVE_SYS_STAT_H
#include <sys/stat.h>
#endif
#ifdef HAVE_FCNTL_H
#include <fcntl.h>
#endif
#ifdef HAVE_STDLIB_H
#include <stdlib.h>
#endif
#ifdef TIME_WITH_SYS_TIME
#include <time.h>
#ifdef HAVE_SYS_TIME_H
#include <sys/time.h>
#endif
#else
#include <time.h>
#endif
#ifdef HAVE_STRING_H
#include <string.h>
#endif
#ifdef HAVE_PROCINFO_H
#include <procinfo.h>
#endif
#ifdef HAVE_SYS_TYPES_H
#include <sys/types.h>
#endif
#ifdef HAVE_SYS_PROC_H
#include <sys/proc.h>
#endif
#ifdef HAVE_SYS_PROCFS_H
#include <sys/procfs.h>
#endif
#ifdef HAVE_CF_H
#include <cf.h>
#endif
#ifdef HAVE_SYS_CFGODM_H
#include <sys/cfgodm.h>
#endif
#ifdef HAVE_SYS_CFGDB_H
#include <sys/cfgdb.h>
#endif
#ifdef HAVE_SYS_SYSTEMCFG_H
#include <sys/systemcfg.h>
#endif
#ifdef HAVE_SYS_PROC_H
#include <sys/proc.h>
#endif
#ifdef HAVE_SYS_PROTOSW_H
#include <sys/protosw.h>
#endif
#ifdef HAVE_LIBPERFSTAT_H
#include <sys/protosw.h>
#include <libperfstat.h>
#endif
#include "process.h"
#include "process_sysdep.h"
/**
* System dependent resource gathering code for AIX
*
* @file
*/
/* There is no prototype for getprocs64 in AIX <= 5.3 */
int getprocs64(void *, int, void *, int, pid_t *, int);
static int page_size;
static int cpu_initialized = 0;
static unsigned long long cpu_total_old = 0ULL;
static unsigned long long cpu_user_old = 0ULL;
static unsigned long long cpu_syst_old = 0ULL;
static unsigned long long cpu_wait_old = 0ULL;
struct procentry64 *procs = NULL;
int init_process_info_sysdep(void) {
perfstat_memory_total_t mem;
if (perfstat_memory_total(NULL, &mem, sizeof(perfstat_memory_total_t), 1) < 1) {
LogError("system statistic error -- perfstat_memory_total failed: %s\n", STRERROR);
return FALSE;
}
page_size = getpagesize();
systeminfo.mem_kbyte_max = (unsigned long)(mem.real_total * (page_size / 1024));
systeminfo.cpus = sysconf(_SC_NPROCESSORS_ONLN);
return TRUE;
}
/**
* This routine returns 'nelem' double precision floats containing
* the load averages in 'loadv'; at most 3 values will be returned.
* @param loadv destination of the load averages
* @param nelem number of averages
* @return: 0 if successful, -1 if failed (and all load averages are 0).
*/
int getloadavg_sysdep (double *loadv, int nelem) {
perfstat_cpu_total_t cpu;
if (perfstat_cpu_total(NULL, &cpu, sizeof(perfstat_cpu_total_t), 1) < 1) {
LogError("system statistic error -- perfstat_cpu_total failed: %s\n", STRERROR);
return -1;
}
switch (nelem) {
case 3:
loadv[2] = (double)cpu.loadavg[2] / (double)(1<<SBITS);
case 2:
loadv[1] = (double)cpu.loadavg[1] / (double)(1<<SBITS);
case 1:
loadv[0] = (double)cpu.loadavg[0] / (double)(1<<SBITS);
}
return TRUE;
}
/**
* Read all processes to initialize the process tree
* @param reference reference of ProcessTree
* @return treesize>0 if succeeded otherwise =0.
*/
int initprocesstree_sysdep(ProcessTree_T ** reference) {
int i;
int treesize;
struct userinfo user;
ProcessTree_T *pt;
pid_t firstproc = 0;
memset(&user, 0, sizeof(struct userinfo));
if ((treesize = getprocs64(NULL, 0, NULL, 0, &firstproc, PID_MAX)) < 0) {
LogError("system statistic error -- getprocs64 failed: %s\n", STRERROR);
return FALSE;
}
procs = CALLOC(sizeof(struct procentry64), treesize);
firstproc = 0;
if ((treesize = getprocs64(procs, sizeof(struct procentry64), NULL, 0, &firstproc, treesize)) < 0) {
FREE(procs);
LogError("system statistic error -- getprocs64 failed: %s\n", STRERROR);
return FALSE;
}
pt = CALLOC(sizeof(ProcessTree_T), treesize);
for (i = 0; i < treesize; i++) {
int fd;
struct psinfo ps;
char filename[STRLEN];
pt[i].cputime = 0;
pt[i].cpu_percent = 0;
pt[i].mem_kbyte = 0;
pt[i].pid = procs[i].pi_pid;
pt[i].ppid = procs[i].pi_ppid;
pt[i].starttime = procs[i].pi_start;
if (procs[i].pi_state == SZOMB) {
pt[i].status_flag |= PROCESS_ZOMBIE;
} else if (getuser(&(procs[i]), sizeof(struct procinfo), &user, sizeof(struct userinfo)) != -1) {
pt[i].mem_kbyte = (user.ui_drss + user.ui_trss) * (page_size / 1024);
pt[i].cputime = (user.ui_ru.ru_utime.tv_sec + user.ui_ru.ru_utime.tv_usec * 1.0e-6 + user.ui_ru.ru_stime.tv_sec + user.ui_ru.ru_stime.tv_usec * 1.0e-6) * 10;
}
snprintf(filename, sizeof(filename), "/proc/%d/psinfo", pt[i].pid);
if ((fd = open(filename, O_RDONLY)) < 0) {
DEBUG("%s: Cannot open proc file %s -- %s\n", prog, filename, STRERROR);
continue;
}
if (read(fd, &ps, sizeof(ps)) < 0) {
DEBUG("%s: Cannot read proc file %s -- %s\n", prog, filename, STRERROR);
if (close(fd) < 0)
LogError("%s: Socket close failed -- %s\n", prog, STRERROR);
return FALSE;
}
if (close(fd) < 0)
LogError("%s: Socket close failed -- %s\n", prog, STRERROR);
pt[i].cmdline = (ps.pr_psargs && *ps.pr_psargs) ? Str_dup(ps.pr_psargs) : Str_dup(procs[i].pi_comm);
}
FREE(procs);
*reference = pt;
return treesize;
}
/**
* This routine returns kbyte of real memory in use.
* @return: TRUE if successful, FALSE if failed (or not available)
*/
int used_system_memory_sysdep(SystemInfo_T *si) {
perfstat_memory_total_t mem;
/* Memory */
if (perfstat_memory_total(NULL, &mem, sizeof(perfstat_memory_total_t), 1) < 1) {
LogError("system statistic error -- perfstat_memory_total failed: %s\n", STRERROR);
return FALSE;
}
si->total_mem_kbyte = (unsigned long)((mem.real_total - mem.real_free - mem.numperm) * (page_size / 1024));
/* Swap */
si->swap_kbyte_max = (unsigned long)(mem.pgsp_total * 4); /* 4kB blocks */
si->total_swap_kbyte = (unsigned long)((mem.pgsp_total - mem.pgsp_free) * 4); /* 4kB blocks */
return TRUE;
}
/**
* This routine returns system/user CPU time in use.
* @return: TRUE if successful, FALSE if failed (or not available)
*/
int used_system_cpu_sysdep(SystemInfo_T *si) {
perfstat_cpu_total_t cpu;
unsigned long long cpu_total;
unsigned long long cpu_total_new = 0ULL;
unsigned long long cpu_user = 0ULL;
unsigned long long cpu_syst = 0ULL;
unsigned long long cpu_wait = 0ULL;
if (perfstat_cpu_total(NULL, &cpu, sizeof(perfstat_cpu_total_t), 1) < 0) {
LogError("system statistic error -- perfstat_cpu_total failed: %s\n", STRERROR);
return -1;
}
cpu_total_new = (cpu.user + cpu.sys + cpu.wait + cpu.idle) / cpu.ncpus;
cpu_total = cpu_total_new - cpu_total_old;
cpu_total_old = cpu_total_new;
cpu_user = cpu.user / cpu.ncpus;
cpu_syst = cpu.sys / cpu.ncpus;
cpu_wait = cpu.wait / cpu.ncpus;
if (cpu_initialized) {
if (cpu_total > 0) {
si->total_cpu_user_percent = 1000 * ((double)(cpu_user - cpu_user_old) / (double)cpu_total);
si->total_cpu_syst_percent = 1000 * ((double)(cpu_syst - cpu_syst_old) / (double)cpu_total);
si->total_cpu_wait_percent = 1000 * ((double)(cpu_wait - cpu_wait_old) / (double)cpu_total);
} else {
si->total_cpu_user_percent = 0;
si->total_cpu_syst_percent = 0;
si->total_cpu_wait_percent = 0;
}
}
cpu_user_old = cpu_user;
cpu_syst_old = cpu_syst;
cpu_wait_old = cpu_wait;
cpu_initialized = 1;
return TRUE;
}