int
getsize (int pid)
{
struct procentry64 entry;
int page_size = sysconf (_SC_PAGESIZE);
pid_t tmp_pid = pid;
if (pid <= 0)
{
return -1;
}
if (getprocs64 (&entry, sizeof (entry), NULL, 0, &tmp_pid, 1) < 0)
{
if (kill (pid, 0) < 0)
{
if (errno == ESRCH)
{
return -1;
}
}
return 1;
}
if (entry.pi_pid != pid)
{
return -1;
}
return (int) (((INT64) entry.pi_dvm) * ((INT64) page_size) / 1024);
}
int stats_checkpoint_initial(struct procentry64 *b)
{
pid_t p_idx=getpid();
int e;
if ((e=getprocs64(b, sizeof(*b), NULL, 0, &p_idx, 1)) >= 0)
{} /* Great */
else
fprintf(stderr,"getprocs64 returned %s, error code %d. Continuing\n",strerror(errno),errno);
return e;
}
int stats_checkpoint(pid_t p_idx, uint64_t pg_cnt, struct procentry64 *a, struct procentry64 *b)
{
int e;
if ((e=getprocs64(b, sizeof(*b), NULL, 0, &p_idx, 1)) >= 0)
printf("Pages scanned=%" PRIu64 ", Minor page faults=%" PRIu64 ", Major page faults=%" PRIu64 "\n",
pg_cnt, b->pi_minflt - a->pi_minflt, b->pi_majflt - a->pi_majflt);
else
fprintf(stderr,"getprocs64 returned %s, error code %d. Continuing\n",strerror(errno),errno);
return e;
}
/** Call getprocs64(3) for exactly 1 PID
*
* This takes care of boring details and handles errors properly.
*
* @param procbuff: the procentry64 structure the result will be stored in.
* @param pid: the PID of the process to get.
*
* @return -1 in case of an error, 0 if successful.
**/
static int
getprocent(struct procentry64 *procbuff, const pid_t pid)
{
pid32_t pid32;
int r;
pid32 = (pid32_t)pid;
r = getprocs64(procbuff, sizeof(struct procentry64),
(struct fdsinfo64 *)NULL, 0,
&pid32, 1);
if (r < 0) {
if (errno == EINVAL)
PyErr_Format(PsiExc_NoSuchProcessError,
"No such PID: %lu", (unsigned long)pid);
else
PyErr_SetFromErrnoWithFilename(PyExc_OSError, "getprocs64()");
return -1;
}
return 0;
}
/**
* Find the location of this program
* @param buf a character buffer to hold the directory name
* @param bufsize the size of buf
* @return the success return code
*/
int Messages_findMyLocation(char* buf, int bufsize)
{
int rc = -1;
#if defined(WIN32)
wchar_t wbuf[256];
#elif defined(AIX)
struct procentry64 processInfo;
pid_t myPid, indexPtr;
#endif
FUNC_ENTRY;
#if defined(WIN32)
rc = GetModuleFileName(NULL, wbuf, bufsize);
wcstombs(buf, wbuf, bufsize);
#elif defined(AIX)
myPid = getpid();
while (getprocs64(&processInfo, sizeof (processInfo), 0, 0, &indexPtr, 1) > 0)
{
if ((pid_t)(processInfo.pi_pid) == myPid)
{
rc = (getargs((void*)&processInfo, sizeof(processInfo), buf, bufsize) == 0) ? strlen(buf) : 0;
break;
}
}
#else /* Linux */
rc = (int)readlink("/proc/self/exe", buf, bufsize);
#endif
if (rc > 0 && rc < bufsize)
{
char* pos;
if ((pos = strrchr(buf, sep)) != NULL)
*pos = '\0'; /* remove trailing program name, leaving just the directory */
rc = 0; /* success */
}
else
rc = -1; /* failure */
FUNC_EXIT_RC(rc);
return rc;
}
/* XXX: why don't we just use proclib? */
gchar*
mono_w32process_get_name (pid_t pid)
{
FILE *fp;
gchar *filename;
gchar buf[256];
gchar *ret = NULL;
#if defined(HOST_SOLARIS) || (defined(_AIX) && !defined(__PASE__))
filename = g_strdup_printf ("/proc/%d/psinfo", pid);
if ((fp = fopen (filename, "r")) != NULL) {
struct psinfo info;
int nread;
nread = fread (&info, sizeof (info), 1, fp);
if (nread == 1) {
ret = g_strdup (info.pr_fname);
}
fclose (fp);
}
g_free (filename);
#elif defined(__PASE__)
/* AIX has a procfs, but it's not available on i */
struct procentry64 proc;
pid_t newpid;
newpid = pid;
if (getprocs64(&proc, sizeof (proc), NULL, NULL, &newpid, 1) == 1) {
ret = g_strdup (proc.pi_comm);
}
#else
memset (buf, '\0', sizeof(buf));
filename = g_strdup_printf ("/proc/%d/exe", pid);
#if defined(HAVE_READLINK)
if (readlink (filename, buf, 255) > 0) {
ret = g_strdup (buf);
}
#endif
g_free (filename);
if (ret != NULL) {
return(ret);
}
filename = g_strdup_printf ("/proc/%d/cmdline", pid);
if ((fp = fopen (filename, "r")) != NULL) {
if (fgets (buf, 256, fp) != NULL) {
ret = g_strdup (buf);
}
fclose (fp);
}
g_free (filename);
if (ret != NULL) {
return(ret);
}
filename = g_strdup_printf ("/proc/%d/stat", pid);
if ((fp = fopen (filename, "r")) != NULL) {
if (fgets (buf, 256, fp) != NULL) {
char *start, *end;
start = strchr (buf, '(');
if (start != NULL) {
end = strchr (start + 1, ')');
if (end != NULL) {
ret = g_strndup (start + 1,
end - start - 1);
}
}
}
fclose (fp);
}
g_free (filename);
#endif
return ret;
}
/**
* 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 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 0;
}
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 0;
}
pt = CALLOC(sizeof(ProcessTree_T), treesize);
for (int 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].zombie = true;
} 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("Cannot open proc file %s -- %s\n", filename, STRERROR);
continue;
}
if (read(fd, &ps, sizeof(ps)) < 0) {
DEBUG("Cannot read proc file %s -- %s\n", filename, STRERROR);
if (close(fd) < 0)
LogError("Socket close failed -- %s\n", STRERROR);
return 0;
}
if (close(fd) < 0)
LogError("Socket close failed -- %s\n", STRERROR);
pt[i].uid = ps.pr_uid;
pt[i].euid = ps.pr_euid;
pt[i].gid = ps.pr_gid;
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;
}
/* Specification. */
#include "getprogname.h"
#include <errno.h> /* get program_invocation_name declaration */
#include <stdlib.h> /* get __argv declaration */
#ifdef _AIX
# include <unistd.h>
# include <procinfo.h>
# include <string.h>
#endif
#ifdef __MVS__
# ifndef _OPEN_SYS
# define _OPEN_SYS
# endif
# include <string.h>
# include <sys/ps.h>
#endif
#ifdef __hpux
# include <unistd.h>
# include <sys/param.h>
# include <sys/pstat.h>
# include <string.h>
#endif
#include "dirname.h"
#ifndef HAVE_GETPROGNAME /* not Mac OS X, FreeBSD, NetBSD, OpenBSD >= 5.4, Cygwin */
char const *
getprogname (void)
{
# if HAVE_DECL_PROGRAM_INVOCATION_SHORT_NAME /* glibc, BeOS */
/* https://www.gnu.org/software/libc/manual/html_node/Error-Messages.html */
return program_invocation_short_name;
# elif HAVE_DECL_PROGRAM_INVOCATION_NAME /* glibc, BeOS */
/* https://www.gnu.org/software/libc/manual/html_node/Error-Messages.html */
return last_component (program_invocation_name);
# elif HAVE_GETEXECNAME /* Solaris */
/* http://docs.oracle.com/cd/E19253-01/816-5168/6mbb3hrb1/index.html */
const char *p = getexecname ();
if (!p)
p = "?";
return last_component (p);
# elif HAVE_DECL___ARGV /* mingw, MSVC */
/* https://msdn.microsoft.com/en-us/library/dn727674.aspx */
const char *p = __argv && __argv[0] ? __argv[0] : "?";
return last_component (p);
# elif HAVE_VAR___PROGNAME /* OpenBSD, QNX */
/* http://man.openbsd.org/style.9 */
/* http://www.qnx.de/developers/docs/6.5.0/index.jsp?topic=%2Fcom.qnx.doc.neutrino_lib_ref%2Fp%2F__progname.html */
/* Be careful to declare this only when we absolutely need it
(OpenBSD 5.1), rather than when it's available. Otherwise,
its mere declaration makes program_invocation_short_name
malfunction (have zero length) with Fedora 25's glibc. */
extern char *__progname;
const char *p = __progname;
return p && p[0] ? p : "?";
# elif _AIX /* AIX */
/* Idea by Bastien ROUCARIÈS,
http://lists.gnu.org/archive/html/bug-gnulib/2010-12/msg00095.html
Reference: http://
ibm.biz/knowctr#ssw_aix_53/com.ibm.aix.basetechref/doc/basetrf1/getprocs.htm
*/
static char *p;
static int first = 1;
if (first)
{
first = 0;
pid_t pid = getpid ();
struct procentry64 procs;
p = (0 < getprocs64 (&procs, sizeof procs, NULL, 0, &pid, 1)
? strdup (procs.pi_comm)
: NULL);
if (!p)
p = "?";
}
return p;
# elif defined __hpux
static char *p;
static int first = 1;
if (first)
{
first = 0;
pid_t pid = getpid ();
struct pst_status status;
p = (0 < pstat_getproc (&status, sizeof status, 0, pid)
? strdup (status.pst_ucomm)
: NULL);
if (!p)
p = "?";
}
return p;
# elif __MVS__ /* z/OS */
/* https://www.ibm.com/support/knowledgecenter/SSLTBW_2.1.0/com.ibm.zos.v2r1.bpxbd00/rtwgetp.htm */
static char *p = "?";
static int first = 1;
if (first)
{
pid_t pid = getpid ();
int token;
W_PSPROC buf;
first = 0;
memset (&buf, 0, sizeof(buf));
buf.ps_cmdptr = (char *) malloc (buf.ps_cmdlen = PS_CMDBLEN_LONG);
buf.ps_conttyptr = (char *) malloc (buf.ps_conttylen = PS_CONTTYBLEN);
buf.ps_pathptr = (char *) malloc (buf.ps_pathlen = PS_PATHBLEN);
if (buf.ps_cmdptr && buf.ps_conttyptr && buf.ps_pathptr)
{
for (token = 0; token >= 0;
token = w_getpsent (token, &buf, sizeof(buf)))
{
if (token > 0 && buf.ps_pid == pid)
{
char *s = strdup (last_component (buf.ps_pathptr));
if (s)
p = s;
break;
}
}
}
free (buf.ps_cmdptr);
free (buf.ps_conttyptr);
free (buf.ps_pathptr);
}
return p;
# else
# error "getprogname module not ported to this OS"
# endif
}
int PROC_MEM(AGENT_REQUEST *request, AGENT_RESULT *result)
{
#define ZBX_VSIZE 0
#define ZBX_RSS 1
#define ZBX_PMEM 2
#define ZBX_SIZE 3
#define ZBX_DSIZE 4
#define ZBX_TSIZE 5
#define ZBX_SDSIZE 6
#define ZBX_DRSS 7
#define ZBX_TRSS 8
/* The pi_???_l2psize fields are described as: log2 of a proc's ??? pg sz */
/* Basically it's bits per page, so define 12 bits (4kb) for earlier AIX */
/* versions that do not support those fields. */
#ifdef _AIX61
# define ZBX_L2PSIZE(field) field
#else
# define ZBX_L2PSIZE(field) 12
#endif
char *param, *procname, *proccomm, *mem_type = NULL;
struct passwd *usrinfo;
struct procentry64 procentry;
pid_t pid = 0;
int do_task, mem_type_code, proccount = 0, invalid_user = 0;
zbx_uint64_t mem_size = 0, byte_value = 0;
double pct_size = 0.0, pct_value = 0.0;
if (5 < request->nparam)
{
SET_MSG_RESULT(result, zbx_strdup(NULL, "Too many parameters."));
return SYSINFO_RET_FAIL;
}
procname = get_rparam(request, 0);
param = get_rparam(request, 1);
if (NULL != param && '\0' != *param)
{
if (NULL == (usrinfo = getpwnam(param)))
invalid_user = 1;
}
else
usrinfo = NULL;
param = get_rparam(request, 2);
if (NULL == param || '\0' == *param || 0 == strcmp(param, "sum"))
do_task = ZBX_DO_SUM;
else if (0 == strcmp(param, "avg"))
do_task = ZBX_DO_AVG;
else if (0 == strcmp(param, "max"))
do_task = ZBX_DO_MAX;
else if (0 == strcmp(param, "min"))
do_task = ZBX_DO_MIN;
else
{
SET_MSG_RESULT(result, zbx_strdup(NULL, "Invalid third parameter."));
return SYSINFO_RET_FAIL;
}
proccomm = get_rparam(request, 3);
mem_type = get_rparam(request, 4);
if (NULL == mem_type || '\0' == *mem_type || 0 == strcmp(mem_type, "vsize"))
{
mem_type_code = ZBX_VSIZE; /* virtual memory size */
}
else if (0 == strcmp(mem_type, "rss"))
{
mem_type_code = ZBX_RSS; /* resident set size */
}
else if (0 == strcmp(mem_type, "pmem"))
{
mem_type_code = ZBX_PMEM; /* percentage of real memory used by process */
}
else if (0 == strcmp(mem_type, "size"))
{
mem_type_code = ZBX_SIZE; /* size of process (code + data) */
}
else if (0 == strcmp(mem_type, "dsize"))
{
mem_type_code = ZBX_DSIZE; /* data size */
}
else if (0 == strcmp(mem_type, "tsize"))
{
mem_type_code = ZBX_TSIZE; /* text size */
}
else if (0 == strcmp(mem_type, "sdsize"))
{
mem_type_code = ZBX_SDSIZE; /* data size from shared library */
}
else if (0 == strcmp(mem_type, "drss"))
{
mem_type_code = ZBX_DRSS; /* data resident set size */
}
else if (0 == strcmp(mem_type, "trss"))
{
mem_type_code = ZBX_TRSS; /* text resident set size */
}
else
{
SET_MSG_RESULT(result, zbx_strdup(NULL, "Invalid fifth parameter."));
return SYSINFO_RET_FAIL;
}
if (1 == invalid_user) /* handle 0 for non-existent user after all parameters have been parsed and validated */
goto out;
while (0 < getprocs64(&procentry, (int)sizeof(struct procentry64), NULL, 0, &pid, 1))
{
if (NULL != procname && '\0' != *procname && 0 != strcmp(procname, procentry.pi_comm))
continue;
if (NULL != usrinfo && usrinfo->pw_uid != procentry.pi_uid)
continue;
if (NULL != proccomm && '\0' != *proccomm && SUCCEED != check_procargs(&procentry, proccomm))
continue;
switch (mem_type_code)
{
case ZBX_VSIZE:
/* historically default proc.mem[] on AIX */
byte_value = (zbx_uint64_t)procentry.pi_size << 12; /* number of pages to bytes */
break;
case ZBX_RSS:
/* try to be compatible with "ps -o rssize" */
byte_value = ((zbx_uint64_t)procentry.pi_drss << ZBX_L2PSIZE(procentry.pi_data_l2psize)) +
((zbx_uint64_t)procentry.pi_trss << ZBX_L2PSIZE(procentry.pi_text_l2psize));
break;
case ZBX_PMEM:
/* try to be compatible with "ps -o pmem" */
pct_value = procentry.pi_prm;
break;
case ZBX_SIZE:
/* try to be compatible with "ps gvw" SIZE column */
byte_value = (zbx_uint64_t)procentry.pi_dvm << ZBX_L2PSIZE(procentry.pi_data_l2psize);
break;
case ZBX_DSIZE:
byte_value = procentry.pi_dsize;
break;
case ZBX_TSIZE:
/* try to be compatible with "ps gvw" TSIZ column */
byte_value = procentry.pi_tsize;
break;
case ZBX_SDSIZE:
byte_value = procentry.pi_sdsize;
break;
case ZBX_DRSS:
byte_value = (zbx_uint64_t)procentry.pi_drss << ZBX_L2PSIZE(procentry.pi_data_l2psize);
break;
case ZBX_TRSS:
byte_value = (zbx_uint64_t)procentry.pi_trss << ZBX_L2PSIZE(procentry.pi_text_l2psize);
break;
}
if (ZBX_PMEM != mem_type_code)
{
if (0 != proccount++)
{
if (ZBX_DO_MAX == do_task)
mem_size = MAX(mem_size, byte_value);
else if (ZBX_DO_MIN == do_task)
mem_size = MIN(mem_size, byte_value);
else
mem_size += byte_value;
}
else
mem_size = byte_value;
}
else
{
if (0 != proccount++)
{
if (ZBX_DO_MAX == do_task)
pct_size = MAX(pct_size, pct_value);
else if (ZBX_DO_MIN == do_task)
pct_size = MIN(pct_size, pct_value);
else
pct_size += pct_value;
}
else
pct_size = pct_value;
}
}
out:
if (ZBX_PMEM != mem_type_code)
{
if (ZBX_DO_AVG == do_task)
SET_DBL_RESULT(result, 0 == proccount ? 0.0 : (double)mem_size / (double)proccount);
else
SET_UI64_RESULT(result, mem_size);
}
else
{
if (ZBX_DO_AVG == do_task)
SET_DBL_RESULT(result, 0 == proccount ? 0.0 : pct_size / (double)proccount);
else
SET_DBL_RESULT(result, pct_size);
}
return SYSINFO_RET_OK;
#undef ZBX_L2PSIZE
#undef ZBX_SIZE
#undef ZBX_RSS
#undef ZBX_VSIZE
#undef ZBX_PMEM
#undef ZBX_TSIZE
#undef ZBX_DSIZE
#undef ZBX_SDSIZE
#undef ZBX_DRSS
#undef ZBX_TRSS
}
int PROC_NUM(AGENT_REQUEST *request, AGENT_RESULT *result)
{
char *param, *procname, *proccomm;
struct passwd *usrinfo;
struct procentry64 procentry;
pid_t pid = 0;
int proccount = 0, invalid_user = 0, zbx_proc_stat;
if (4 < request->nparam)
{
SET_MSG_RESULT(result, zbx_strdup(NULL, "Too many parameters."));
return SYSINFO_RET_FAIL;
}
procname = get_rparam(request, 0);
param = get_rparam(request, 1);
if (NULL != param && '\0' != *param)
{
if (NULL == (usrinfo = getpwnam(param)))
invalid_user = 1;
}
else
usrinfo = NULL;
param = get_rparam(request, 2);
if (NULL == param || '\0' == *param || 0 == strcmp(param, "all"))
zbx_proc_stat = ZBX_PROC_STAT_ALL;
else if (0 == strcmp(param, "run"))
zbx_proc_stat = ZBX_PROC_STAT_RUN;
else if (0 == strcmp(param, "sleep"))
zbx_proc_stat = ZBX_PROC_STAT_SLEEP;
else if (0 == strcmp(param, "zomb"))
zbx_proc_stat = ZBX_PROC_STAT_ZOMB;
else
{
SET_MSG_RESULT(result, zbx_strdup(NULL, "Invalid third parameter."));
return SYSINFO_RET_FAIL;
}
proccomm = get_rparam(request, 3);
if (1 == invalid_user) /* handle 0 for non-existent user after all parameters have been parsed and validated */
goto out;
while (0 < getprocs64(&procentry, (int)sizeof(struct procentry64), NULL, 0, &pid, 1))
{
if (NULL != procname && '\0' != *procname && 0 != strcmp(procname, procentry.pi_comm))
continue;
if (NULL != usrinfo && usrinfo->pw_uid != procentry.pi_uid)
continue;
if (SUCCEED != check_procstate(&procentry, zbx_proc_stat))
continue;
if (NULL != proccomm && '\0' != *proccomm && SUCCEED != check_procargs(&procentry, proccomm))
continue;
proccount++;
}
out:
SET_UI64_RESULT(result, proccount);
return SYSINFO_RET_OK;
}
sg_process_stats *sg_get_process_stats(int *entries){
VECTOR_DECLARE_STATIC(proc_state, sg_process_stats, 64,
proc_state_init, proc_state_destroy);
int proc_state_size = 0;
sg_process_stats *proc_state_ptr;
#ifdef HPUX
struct pst_status pstat_procinfo[PROCESS_BATCH];
long procidx = 0;
long long pagesize;
int num, i;
#endif
#ifdef AIX
struct procentry64 *procs = NULL;
long long pagesize;
int fetched = 0;
pid_t index = 0;
unsigned proc_idx;
time_t utime, stime;
int ncpus;
struct timeval now_tval;
double now_time;
char cmndline[ARG_MAX];
char comm[ARG_MAX];
struct procentry64 curproc_for_getargs;
#define PROCS_TO_FETCH 1000
#endif
#ifdef ALLBSD
int mib[4];
size_t size;
struct kinfo_proc *kp_stats;
int procs, i;
char *proctitle;
#if (defined(FREEBSD) && !defined(FREEBSD5)) || defined(DFBSD)
kvm_t *kvmd;
char **args, **argsp;
int argslen = 0;
#else
long buflen;
char *p, *proctitletmp;
#endif
#ifdef NETBSD2
int lwps;
struct kinfo_lwp *kl_stats;
#endif
#endif
#if defined(SOLARIS) || defined(LINUX)
DIR *proc_dir;
struct dirent *dir_entry;
char filename[MAX_FILE_LENGTH];
FILE *f;
#ifdef SOLARIS
psinfo_t process_info;
#endif
#ifdef LINUX
char s;
/* If someone has a executable of 4k filename length, they deserve to get it truncated :) */
char ps_name[4096];
char *ptr;
VECTOR_DECLARE_STATIC(psargs, char, 128, NULL, NULL);
unsigned long stime, utime, starttime;
int x;
int fn;
int len;
int rc;
time_t uptime;
long tickspersec;
#endif
#ifdef LINUX
if ((f=fopen("/proc/uptime", "r")) == NULL) {
sg_set_error_with_errno(SG_ERROR_OPEN, "/proc/uptime");
return NULL;
}
if((fscanf(f,"%lu %*d",&uptime)) != 1){
sg_set_error(SG_ERROR_PARSE, NULL);
return NULL;
}
fclose(f);
#endif
if((proc_dir=opendir(PROC_LOCATION))==NULL){
sg_set_error_with_errno(SG_ERROR_OPENDIR, PROC_LOCATION);
return NULL;
}
while((dir_entry=readdir(proc_dir))!=NULL){
if(atoi(dir_entry->d_name) == 0) continue;
#ifdef SOLARIS
snprintf(filename, MAX_FILE_LENGTH, "/proc/%s/psinfo", dir_entry->d_name);
#endif
#ifdef LINUX
snprintf(filename, MAX_FILE_LENGTH, "/proc/%s/stat", dir_entry->d_name);
#endif
if((f=fopen(filename, "r"))==NULL){
/* Open failed.. Process since vanished, or the path was too long.
* Ah well, move onwards to the next one */
continue;
}
#ifdef SOLARIS
fread(&process_info, sizeof(psinfo_t), 1, f);
fclose(f);
#endif
if (VECTOR_RESIZE(proc_state, proc_state_size + 1) < 0) {
return NULL;
}
proc_state_ptr = proc_state+proc_state_size;
#ifdef SOLARIS
proc_state_ptr->pid = process_info.pr_pid;
proc_state_ptr->parent = process_info.pr_ppid;
proc_state_ptr->pgid = process_info.pr_pgid;
proc_state_ptr->uid = process_info.pr_uid;
proc_state_ptr->euid = process_info.pr_euid;
proc_state_ptr->gid = process_info.pr_gid;
proc_state_ptr->egid = process_info.pr_egid;
proc_state_ptr->proc_size = (process_info.pr_size) * 1024;
proc_state_ptr->proc_resident = (process_info.pr_rssize) * 1024;
proc_state_ptr->time_spent = process_info.pr_time.tv_sec;
proc_state_ptr->cpu_percent = (process_info.pr_pctcpu * 100.0) / 0x8000;
proc_state_ptr->nice = (int)process_info.pr_lwp.pr_nice - 20;
if (sg_update_string(&proc_state_ptr->process_name,
process_info.pr_fname) < 0) {
return NULL;
}
if (sg_update_string(&proc_state_ptr->proctitle,
process_info.pr_psargs) < 0) {
return NULL;
}
switch (process_info.pr_lwp.pr_state) {
case 1:
proc_state_ptr->state = SG_PROCESS_STATE_SLEEPING;
break;
case 2:
case 5:
proc_state_ptr->state = SG_PROCESS_STATE_RUNNING;
break;
case 3:
proc_state_ptr->state = SG_PROCESS_STATE_ZOMBIE;
break;
case 4:
proc_state_ptr->state = SG_PROCESS_STATE_STOPPED;
break;
}
#endif
#ifdef LINUX
x = fscanf(f, "%d %4096s %c %d %d %*d %*d %*d %*u %*u %*u %*u %*u %lu %lu %*d %*d %*d %d %*d %*d %lu %llu %llu %*u %*u %*u %*u %*u %*u %*u %*u %*u %*u %*u %*u %*u %*d %*d\n", &(proc_state_ptr->pid), ps_name, &s, &(proc_state_ptr->parent), &(proc_state_ptr->pgid), &utime, &stime, &(proc_state_ptr->nice), &starttime, &(proc_state_ptr->proc_size), &(proc_state_ptr->proc_resident));
/* +3 becuase man page says "Resident Set Size: number of pages the process has in real memory, minus 3 for administrative purposes." */
proc_state_ptr->proc_resident = (proc_state_ptr->proc_resident + 3) * getpagesize();
switch (s) {
case 'S':
proc_state_ptr->state = SG_PROCESS_STATE_SLEEPING;
break;
case 'R':
proc_state_ptr->state = SG_PROCESS_STATE_RUNNING;
break;
case 'Z':
proc_state_ptr->state = SG_PROCESS_STATE_ZOMBIE;
break;
case 'T':
case 'D':
proc_state_ptr->state = SG_PROCESS_STATE_STOPPED;
break;
}
/* pa_name[0] should = '(' */
ptr = strchr(&ps_name[1], ')');
if(ptr !=NULL) *ptr='\0';
if (sg_update_string(&proc_state_ptr->process_name,
&ps_name[1]) < 0) {
return NULL;
}
/* cpu */
proc_state_ptr->cpu_percent = (100.0 * (utime + stime)) / ((uptime * 100.0) - starttime);
tickspersec = sysconf (_SC_CLK_TCK);
if (tickspersec < 0) {
proc_state_ptr->time_spent = 0;
}
else {
proc_state_ptr->time_spent = (utime + stime) / tickspersec;
}
fclose(f);
/* uid / gid */
snprintf(filename, MAX_FILE_LENGTH, "/proc/%s/status", dir_entry->d_name);
if ((f=fopen(filename, "r")) == NULL) {
/* Open failed.. Process since vanished, or the path was too long.
* Ah well, move onwards to the next one */
continue;
}
if((ptr=sg_f_read_line(f, "Uid:"))==NULL){
fclose(f);
continue;
}
sscanf(ptr, "Uid:\t%d\t%d\t%*d\t%*d\n", &(proc_state_ptr->uid), &(proc_state_ptr->euid));
if((ptr=sg_f_read_line(f, "Gid:"))==NULL){
fclose(f);
continue;
}
sscanf(ptr, "Gid:\t%d\t%d\t%*d\t%*d\n", &(proc_state_ptr->gid), &(proc_state_ptr->egid));
fclose(f);
/* proctitle */
snprintf(filename, MAX_FILE_LENGTH, "/proc/%s/cmdline", dir_entry->d_name);
if((fn=open(filename, O_RDONLY)) == -1){
/* Open failed.. Process since vanished, or the path was too long.
* Ah well, move onwards to the next one */
continue;
}
#define READ_BLOCK_SIZE 128
len = 0;
do {
if (VECTOR_RESIZE(psargs, len + READ_BLOCK_SIZE) < 0) {
return NULL;
}
rc = read(fn, psargs + len, READ_BLOCK_SIZE);
if (rc > 0) {
len += rc;
}
} while (rc == READ_BLOCK_SIZE);
close(fn);
if (rc == -1) {
/* Read failed; move on. */
continue;
}
/* Turn \0s into spaces within the command line. */
ptr = psargs;
for(x = 0; x < len; x++) {
if (*ptr == '\0') *ptr = ' ';
ptr++;
}
if (len == 0) {
/* We want psargs to be NULL. */
if (VECTOR_RESIZE(psargs, 0) < 0) {
return NULL;
}
} else {
/* Not empty, so append a \0. */
if (VECTOR_RESIZE(psargs, len + 1) < 0) {
return NULL;
}
psargs[len] = '\0';
}
if (sg_update_string(&proc_state_ptr->proctitle, psargs) < 0) {
return NULL;
}
#endif
proc_state_size++;
}
closedir(proc_dir);
#endif
#ifdef ALLBSD
mib[0] = CTL_KERN;
mib[1] = KERN_PROC;
mib[2] = KERN_PROC_ALL;
if(sysctl(mib, 3, NULL, &size, NULL, 0) < 0) {
sg_set_error_with_errno(SG_ERROR_SYSCTL,
"CTL_KERN.KERN_PROC.KERN_PROC_ALL");
return NULL;
}
procs = size / sizeof(struct kinfo_proc);
kp_stats = sg_malloc(size);
if(kp_stats == NULL) {
return NULL;
}
memset(kp_stats, 0, size);
if(sysctl(mib, 3, kp_stats, &size, NULL, 0) < 0) {
sg_set_error_with_errno(SG_ERROR_SYSCTL,
"CTL_KERN.KERN_PROC.KERN_PROC_ALL");
free(kp_stats);
return NULL;
}
#if (defined(FREEBSD) && !defined(FREEBSD5)) || defined(DFBSD)
kvmd = sg_get_kvm2();
#endif
for (i = 0; i < procs; i++) {
const char *name;
#ifdef FREEBSD5
if (kp_stats[i].ki_stat == 0) {
#else
if (kp_stats[i].kp_proc.p_stat == 0) {
#endif
/* FreeBSD 5 deliberately overallocates the array that
* the sysctl returns, so we'll get a few junk
* processes on the end that we have to ignore. (Search
* for "overestimate by 5 procs" in
* src/sys/kern/kern_proc.c for more details.) */
continue;
}
if (VECTOR_RESIZE(proc_state, proc_state_size + 1) < 0) {
return NULL;
}
proc_state_ptr = proc_state+proc_state_size;
#ifdef FREEBSD5
name = kp_stats[i].ki_comm;
#elif defined(DFBSD)
name = kp_stats[i].kp_thread.td_comm;
#else
name = kp_stats[i].kp_proc.p_comm;
#endif
if (sg_update_string(&proc_state_ptr->process_name, name) < 0) {
return NULL;
}
#if defined(FREEBSD5) || defined(NETBSD) || defined(OPENBSD)
#ifdef FREEBSD5
mib[2] = KERN_PROC_ARGS;
mib[3] = kp_stats[i].ki_pid;
#else
mib[1] = KERN_PROC_ARGS;
mib[2] = kp_stats[i].kp_proc.p_pid;
mib[3] = KERN_PROC_ARGV;
#endif
free(proc_state_ptr->proctitle);
proc_state_ptr->proctitle = NULL;
/* Starting size - we'll double this straight away */
#define PROCTITLE_START_SIZE 64
buflen = PROCTITLE_START_SIZE;
size = buflen;
proctitle = NULL;
do {
if((long) size >= buflen) {
buflen *= 2;
size = buflen;
proctitletmp = sg_realloc(proctitle, buflen);
if(proctitletmp == NULL) {
free(proctitle);
proctitle = NULL;
proc_state_ptr->proctitle = NULL;
size = 0;
break;
}
proctitle = proctitletmp;
bzero(proctitle, buflen);
}
if(sysctl(mib, 4, proctitle, &size, NULL, 0) < 0) {
free(proctitle);
proctitle = NULL;
proc_state_ptr->proctitle = NULL;
size = 0;
break;
}
} while((long) size >= buflen);
if(size > 0) {
proc_state_ptr->proctitle = sg_malloc(size+1);
if(proc_state_ptr->proctitle == NULL) {
return NULL;
}
p = proctitle;
#ifdef OPENBSD
/* On OpenBSD, this value has the argv pointers (which
* are terminated by a NULL) at the front, so we have
* to skip over them to get to the strings. */
while (*(char ***)p != NULL) {
p += sizeof(char **);
}
p += sizeof(char **);
#endif
proc_state_ptr->proctitle[0] = '\0';
do {
sg_strlcat(proc_state_ptr->proctitle, p, size+1);
sg_strlcat(proc_state_ptr->proctitle, " ", size+1);
p += strlen(p) + 1;
} while (p < proctitle + size);
free(proctitle);
proctitle = NULL;
/* remove trailing space */
proc_state_ptr->proctitle[strlen(proc_state_ptr->proctitle)-1] = '\0';
}
else {
if(proctitle != NULL) {
free(proctitle);
proctitle = NULL;
}
proc_state_ptr->proctitle = NULL;
}
#else
free(proc_state_ptr->proctitle);
proc_state_ptr->proctitle = NULL;
if(kvmd != NULL) {
args = kvm_getargv(kvmd, &(kp_stats[i]), 0);
if(args != NULL) {
argsp = args;
while(*argsp != NULL) {
argslen += strlen(*argsp) + 1;
argsp++;
}
proctitle = sg_malloc(argslen + 1);
proctitle[0] = '\0';
if(proctitle == NULL) {
return NULL;
}
while(*args != NULL) {
sg_strlcat(proctitle, *args, argslen + 1);
sg_strlcat(proctitle, " ", argslen + 1);
args++;
}
/* remove trailing space */
proctitle[strlen(proctitle)-1] = '\0';
proc_state_ptr->proctitle = proctitle;
}
else {
proc_state_ptr->proctitle = NULL;
}
}
else {
proc_state_ptr->proctitle = NULL;
}
#endif
#ifdef FREEBSD5
proc_state_ptr->pid = kp_stats[i].ki_pid;
proc_state_ptr->parent = kp_stats[i].ki_ppid;
proc_state_ptr->pgid = kp_stats[i].ki_pgid;
#else
proc_state_ptr->pid = kp_stats[i].kp_proc.p_pid;
proc_state_ptr->parent = kp_stats[i].kp_eproc.e_ppid;
proc_state_ptr->pgid = kp_stats[i].kp_eproc.e_pgid;
#endif
#ifdef FREEBSD5
proc_state_ptr->uid = kp_stats[i].ki_ruid;
proc_state_ptr->euid = kp_stats[i].ki_uid;
proc_state_ptr->gid = kp_stats[i].ki_rgid;
proc_state_ptr->egid = kp_stats[i].ki_svgid;
#elif defined(DFBSD)
proc_state_ptr->uid = kp_stats[i].kp_eproc.e_ucred.cr_ruid;
proc_state_ptr->euid = kp_stats[i].kp_eproc.e_ucred.cr_svuid;
proc_state_ptr->gid = kp_stats[i].kp_eproc.e_ucred.cr_rgid;
proc_state_ptr->egid = kp_stats[i].kp_eproc.e_ucred.cr_svgid;
#else
proc_state_ptr->uid = kp_stats[i].kp_eproc.e_pcred.p_ruid;
proc_state_ptr->euid = kp_stats[i].kp_eproc.e_pcred.p_svuid;
proc_state_ptr->gid = kp_stats[i].kp_eproc.e_pcred.p_rgid;
proc_state_ptr->egid = kp_stats[i].kp_eproc.e_pcred.p_svgid;
#endif
#ifdef FREEBSD5
proc_state_ptr->proc_size = kp_stats[i].ki_size;
/* This is in pages */
proc_state_ptr->proc_resident =
kp_stats[i].ki_rssize * getpagesize();
/* This is in microseconds */
proc_state_ptr->time_spent = kp_stats[i].ki_runtime / 1000000;
proc_state_ptr->cpu_percent =
((double)kp_stats[i].ki_pctcpu / FSCALE) * 100.0;
proc_state_ptr->nice = kp_stats[i].ki_nice;
#else
proc_state_ptr->proc_size =
kp_stats[i].kp_eproc.e_vm.vm_map.size;
/* This is in pages */
proc_state_ptr->proc_resident =
kp_stats[i].kp_eproc.e_vm.vm_rssize * getpagesize();
#if defined(NETBSD) || defined(OPENBSD)
proc_state_ptr->time_spent =
kp_stats[i].kp_proc.p_rtime.tv_sec;
#elif defined(DFBSD)
proc_state_ptr->time_spent =
( kp_stats[i].kp_thread.td_uticks +
kp_stats[i].kp_thread.td_sticks +
kp_stats[i].kp_thread.td_iticks ) / 1000000;
#else
/* This is in microseconds */
proc_state_ptr->time_spent =
kp_stats[i].kp_proc.p_runtime / 1000000;
#endif
proc_state_ptr->cpu_percent =
((double)kp_stats[i].kp_proc.p_pctcpu / FSCALE) * 100.0;
proc_state_ptr->nice = kp_stats[i].kp_proc.p_nice;
#endif
#ifdef NETBSD2
{
size_t size;
int mib[5];
mib[0] = CTL_KERN;
mib[1] = KERN_LWP;
mib[2] = kp_stats[i].kp_proc.p_pid;
mib[3] = sizeof(struct kinfo_lwp);
mib[4] = 0;
if(sysctl(mib, 5, NULL, &size, NULL, 0) < 0) {
sg_set_error_with_errno(SG_ERROR_SYSCTL, "CTL_KERN.KERN_LWP.pid.structsize.0");
return NULL;
}
lwps = size / sizeof(struct kinfo_lwp);
mib[4] = lwps;
kl_stats = sg_malloc(size);
if(kl_stats == NULL) {
return NULL;
}
if(sysctl(mib, 5, kl_stats, &size, NULL, 0) < 0) {
sg_set_error_with_errno(SG_ERROR_SYSCTL, "CTL_KERN.KERN_LWP.pid.structsize.buffersize");
return NULL;
}
}
switch(kp_stats[i].kp_proc.p_stat) {
case SIDL:
proc_state_ptr->state = SG_PROCESS_STATE_RUNNING;
break;
case SACTIVE:
{
int i;
for(i = 0; i < lwps; i++) {
switch(kl_stats[i].l_stat) {
case LSONPROC:
case LSRUN:
proc_state_ptr->state = SG_PROCESS_STATE_RUNNING;
goto end;
case LSSLEEP:
proc_state_ptr->state = SG_PROCESS_STATE_SLEEPING;
goto end;
case LSSTOP:
case LSSUSPENDED:
proc_state_ptr->state = SG_PROCESS_STATE_STOPPED;
goto end;
}
proc_state_ptr->state = SG_PROCESS_STATE_UNKNOWN;
}
end: ;
}
break;
case SSTOP:
proc_state_ptr->state = SG_PROCESS_STATE_STOPPED;
break;
case SZOMB:
proc_state_ptr->state = SG_PROCESS_STATE_ZOMBIE;
break;
default:
proc_state_ptr->state = SG_PROCESS_STATE_UNKNOWN;
break;
}
free(kl_stats);
#else
#ifdef FREEBSD5
switch (kp_stats[i].ki_stat) {
#else
switch (kp_stats[i].kp_proc.p_stat) {
#endif
case SIDL:
case SRUN:
#ifdef SONPROC
case SONPROC: /* NetBSD */
#endif
proc_state_ptr->state = SG_PROCESS_STATE_RUNNING;
break;
case SSLEEP:
#ifdef SWAIT
case SWAIT: /* FreeBSD 5 */
#endif
#ifdef SLOCK
case SLOCK: /* FreeBSD 5 */
#endif
proc_state_ptr->state = SG_PROCESS_STATE_SLEEPING;
break;
case SSTOP:
proc_state_ptr->state = SG_PROCESS_STATE_STOPPED;
break;
case SZOMB:
#ifdef SDEAD
case SDEAD: /* OpenBSD & NetBSD */
#endif
proc_state_ptr->state = SG_PROCESS_STATE_ZOMBIE;
break;
default:
proc_state_ptr->state = SG_PROCESS_STATE_UNKNOWN;
break;
}
#endif
proc_state_size++;
}
free(kp_stats);
#endif
#ifdef HPUX
if ((pagesize = sysconf(_SC_PAGESIZE)) == -1) {
sg_set_error_with_errno(SG_ERROR_SYSCONF, "_SC_PAGESIZE");
return NULL;
}
while (1) {
num = pstat_getproc(pstat_procinfo, sizeof pstat_procinfo[0],
PROCESS_BATCH, procidx);
if (num == -1) {
sg_set_error_with_errno(SG_ERROR_PSTAT,
"pstat_getproc");
return NULL;
} else if (num == 0) {
break;
}
for (i = 0; i < num; i++) {
struct pst_status *pi = &pstat_procinfo[i];
if (VECTOR_RESIZE(proc_state, proc_state_size + 1) < 0) {
return NULL;
}
proc_state_ptr = proc_state+proc_state_size;
proc_state_ptr->pid = pi->pst_pid;
proc_state_ptr->parent = pi->pst_ppid;
proc_state_ptr->pgid = pi->pst_pgrp;
proc_state_ptr->uid = pi->pst_uid;
proc_state_ptr->euid = pi->pst_euid;
proc_state_ptr->gid = pi->pst_gid;
proc_state_ptr->egid = pi->pst_egid;
proc_state_ptr->proc_size = (pi->pst_dsize + pi->pst_tsize + pi->pst_ssize) * pagesize;
proc_state_ptr->proc_resident = pi->pst_rssize * pagesize;
proc_state_ptr->time_spent = pi->pst_time;
proc_state_ptr->cpu_percent = (pi->pst_pctcpu * 100.0) / 0x8000;
proc_state_ptr->nice = pi->pst_nice;
if (sg_update_string(&proc_state_ptr->process_name,
pi->pst_ucomm) < 0) {
return NULL;
}
if (sg_update_string(&proc_state_ptr->proctitle,
pi->pst_cmd) < 0) {
return NULL;
}
switch (pi->pst_stat) {
case PS_SLEEP:
proc_state_ptr->state = SG_PROCESS_STATE_SLEEPING;
break;
case PS_RUN:
proc_state_ptr->state = SG_PROCESS_STATE_RUNNING;
break;
case PS_STOP:
proc_state_ptr->state = SG_PROCESS_STATE_STOPPED;
break;
case PS_ZOMBIE:
proc_state_ptr->state = SG_PROCESS_STATE_ZOMBIE;
break;
case PS_IDLE:
case PS_OTHER:
proc_state_ptr->state = SG_PROCESS_STATE_UNKNOWN;
break;
}
proc_state_size++;
}
procidx = pstat_procinfo[num - 1].pst_idx + 1;
}
#endif
#ifdef AIX
#define TVALU_TO_SEC(x) ((x).tv_sec + ((double)((x).tv_usec) / 1000000.0))
#define TVALN_TO_SEC(x) ((x).tv_sec + ((double)((x).tv_usec) / 1000000000.0))
ncpus = sysconf(_SC_NPROCESSORS_ONLN);
if( -1 == ncpus ) {
ncpus = 1; /* sysconf error - assume 1 */
}
if ((pagesize = sysconf(_SC_PAGESIZE)) == -1) {
sg_set_error_with_errno(SG_ERROR_SYSCONF, "_SC_PAGESIZE");
return NULL;
}
proc_idx = 0;
procs = /* (struct procentry64 *) */ malloc(sizeof(*procs) * PROCS_TO_FETCH);
if(NULL == procs) {
sg_set_error_with_errno(SG_ERROR_MALLOC, "sg_get_process_stats");
return 0;
}
gettimeofday(&now_tval, 0);
now_time = TVALU_TO_SEC(now_tval);
/* keep on grabbing chunks of processes until getprocs returns a smaller
block than we asked for */
do {
int i;
fetched = getprocs64(procs, sizeof(*procs), NULL, 0, &index, PROCS_TO_FETCH);
if (VECTOR_RESIZE(proc_state, proc_state_size + fetched) < 0) {
sg_set_error_with_errno(SG_ERROR_MALLOC, "sg_get_process_stats");
free(procs);
return NULL;
}
for( i = 0; i < fetched; ++i ) {
struct procentry64 *pi = procs+i;
int zombie = 0;
proc_state_ptr = proc_state + proc_idx;
zombie = 0;
/* set a descriptive name for the process state */
switch( pi->pi_state ) {
case SSLEEP:
proc_state_ptr->state = SG_PROCESS_STATE_SLEEPING;
break;
case SRUN:
proc_state_ptr->state = SG_PROCESS_STATE_RUNNING;
break;
case SZOMB:
proc_state_ptr->state = SG_PROCESS_STATE_ZOMBIE;
zombie = 1;
break;
case SSTOP:
proc_state_ptr->state = SG_PROCESS_STATE_STOPPED;
break;
case SACTIVE:
proc_state_ptr->state = SG_PROCESS_STATE_RUNNING;
break;
case SIDL:
default:
proc_state_ptr->state = SG_PROCESS_STATE_UNKNOWN;
break;
}
if( zombie ) {
utime = pi->pi_utime;
stime = pi->pi_stime;
} else {
utime = TVALN_TO_SEC(pi->pi_ru.ru_utime) + TVALN_TO_SEC(pi->pi_cru.ru_utime);
stime = TVALN_TO_SEC(pi->pi_ru.ru_stime) + TVALN_TO_SEC(pi->pi_cru.ru_stime);
}
proc_state_ptr->pid = pi->pi_pid;
proc_state_ptr->parent = pi->pi_ppid;
proc_state_ptr->pgid = pi->pi_pgrp;
proc_state_ptr->uid = pi->pi_cred.crx_ruid;
proc_state_ptr->euid = pi->pi_cred.crx_uid;
proc_state_ptr->gid = pi->pi_cred.crx_rgid;
proc_state_ptr->egid = pi->pi_cred.crx_gid;
proc_state_ptr->proc_size = pi->pi_size;
proc_state_ptr->proc_resident = pi->pi_drss + pi->pi_trss; /* XXX might be wrong, see P::PT */
proc_state_ptr->time_spent = utime + stime;
proc_state_ptr->cpu_percent = (((double)(utime + stime) * 100) / ( now_time - pi->pi_start )) / ncpus;
proc_state_ptr->nice = pi->pi_nice;
/* determine comm & cmndline */
if( (pi->pi_flags & SKPROC) == SKPROC ) {
if( pi->pi_pid == 0 ) {
snprintf(comm, ARG_MAX, "kproc (swapper)");
snprintf(cmndline, ARG_MAX, "kproc (swapper)");
} else {
snprintf(comm, ARG_MAX, "kproc (%s)", pi->pi_comm);
snprintf(cmndline, ARG_MAX, "kproc (%s)", pi->pi_comm);
}
} else {
snprintf(comm, ARG_MAX, "%s", pi->pi_comm);
curproc_for_getargs.pi_pid = pi->pi_pid;
if( getargs(&curproc_for_getargs, sizeof(curproc_for_getargs), cmndline, ARG_MAX) < 0 ) {
snprintf(cmndline, ARG_MAX, "%s", pi->pi_comm);
} else {
int done = 0;
/* replace NUL characters in command line with spaces */
char *c = cmndline;
while( ! done ) {
if( *c == '\0' ) {
if( *(c+1) == '\0' ) {
done = 1;
} else {
*c++ = ' ';
}
} else {
++c;
}
}
}
}
if (sg_update_string(&proc_state_ptr->process_name, comm) < 0) {
free(procs);
return NULL;
}
if (sg_update_string(&proc_state_ptr->proctitle, cmndline) < 0) {
free(procs);
return NULL;
}
proc_idx++;
}
} while( fetched >= PROCS_TO_FETCH );
proc_state_size = proc_idx;
free(procs);
#endif
#ifdef CYGWIN
sg_set_error(SG_ERROR_UNSUPPORTED, "Cygwin");
return NULL;
#endif
#ifdef WIN32
/* FIXME The data needed for this is probably do able with the
* "performance registry". Although using this appears to be a black
* art and closely guarded secret.
* This is not directly used in ihost, so not considered a priority */
sg_set_error(SG_ERROR_UNSUPPORTED, "Win32");
return NULL;
#endif
*entries = proc_state_size;
return proc_state;
}
sg_process_count *sg_get_process_count() {
static sg_process_count process_stat;
#ifndef WIN32
sg_process_stats *ps;
int ps_size, x;
#else
DWORD aProcesses[1024];
DWORD cbNeeded;
#endif
process_stat.sleeping = 0;
process_stat.running = 0;
process_stat.zombie = 0;
process_stat.stopped = 0;
process_stat.total = 0;
#ifndef WIN32
ps = sg_get_process_stats(&ps_size);
if (ps == NULL) {
return NULL;
}
for(x = 0; x < ps_size; x++) {
switch (ps->state) {
case SG_PROCESS_STATE_RUNNING:
process_stat.running++;
break;
case SG_PROCESS_STATE_SLEEPING:
process_stat.sleeping++;
break;
case SG_PROCESS_STATE_STOPPED:
process_stat.stopped++;
break;
case SG_PROCESS_STATE_ZOMBIE:
process_stat.zombie++;
break;
default:
/* currently no mapping for SG_PROCESS_STATE_UNKNOWN in
* sg_process_count */
break;
}
ps++;
}
process_stat.total = ps_size;
#else
if (!EnumProcesses(aProcesses, sizeof(aProcesses), &cbNeeded))
return NULL;
process_stat.total = cbNeeded / sizeof(DWORD);
#endif
return &process_stat;
}
int sg_process_compare_name(const void *va, const void *vb) {
const sg_process_stats *a = (sg_process_stats *)va;
const sg_process_stats *b = (sg_process_stats *)vb;
return strcmp(a->process_name, b->process_name);
}
int sg_process_compare_pid(const void *va, const void *vb) {
const sg_process_stats *a = (sg_process_stats *)va;
const sg_process_stats *b = (sg_process_stats *)vb;
if (a->pid < b->pid) {
return -1;
} else if (a->pid == b->pid) {
return 0;
} else {
return 1;
}
}
int sg_process_compare_uid(const void *va, const void *vb) {
const sg_process_stats *a = (sg_process_stats *)va;
const sg_process_stats *b = (sg_process_stats *)vb;
if (a->uid < b->uid) {
return -1;
} else if (a->uid == b->uid) {
return 0;
} else {
return 1;
}
}
int sg_process_compare_gid(const void *va, const void *vb) {
const sg_process_stats *a = (sg_process_stats *)va;
const sg_process_stats *b = (sg_process_stats *)vb;
if (a->gid < b->gid) {
return -1;
} else if (a->gid == b->gid) {
return 0;
} else {
return 1;
}
}
int sg_process_compare_size(const void *va, const void *vb) {
const sg_process_stats *a = (sg_process_stats *)va;
const sg_process_stats *b = (sg_process_stats *)vb;
if (a->proc_size < b->proc_size) {
return -1;
} else if (a->proc_size == b->proc_size) {
return 0;
} else {
return 1;
}
}
int sg_process_compare_res(const void *va, const void *vb) {
const sg_process_stats *a = (sg_process_stats *)va;
const sg_process_stats *b = (sg_process_stats *)vb;
if (a->proc_resident < b->proc_resident) {
return -1;
} else if (a->proc_resident == b->proc_resident) {
return 0;
} else {
return 1;
}
}
int sg_process_compare_cpu(const void *va, const void *vb) {
const sg_process_stats *a = (sg_process_stats *)va;
const sg_process_stats *b = (sg_process_stats *)vb;
if (a->cpu_percent < b->cpu_percent) {
return -1;
} else if (a->cpu_percent == b->cpu_percent) {
return 0;
} else {
return 1;
}
}
int sg_process_compare_time(const void *va, const void *vb) {
const sg_process_stats *a = (sg_process_stats *)va;
const sg_process_stats *b = (sg_process_stats *)vb;
if (a->time_spent < b->time_spent) {
return -1;
} else if (a->time_spent == b->time_spent) {
return 0;
} else {
return 1;
}
}
int PROC_MEM(AGENT_REQUEST *request, AGENT_RESULT *result)
{
char *param, *procname, *proccomm;
struct passwd *usrinfo;
struct procentry64 procentry;
pid_t pid = 0;
int do_task;
zbx_uint64_t memsize = 0, proccount = 0, value;
if (4 < request->nparam)
{
SET_MSG_RESULT(result, zbx_strdup(NULL, "Too many parameters."));
return SYSINFO_RET_FAIL;
}
procname = get_rparam(request, 0);
param = get_rparam(request, 1);
if (NULL != param && '\0' != *param)
{
if (NULL == (usrinfo = getpwnam(param)))
{
SET_MSG_RESULT(result, zbx_strdup(NULL, "Cannot obtain user information."));
return SYSINFO_RET_FAIL;
}
}
else
usrinfo = NULL;
param = get_rparam(request, 2);
if (NULL == param || '\0' == *param || 0 == strcmp(param, "sum"))
do_task = ZBX_DO_SUM;
else if (0 == strcmp(param, "avg"))
do_task = ZBX_DO_AVG;
else if (0 == strcmp(param, "max"))
do_task = ZBX_DO_MAX;
else if (0 == strcmp(param, "min"))
do_task = ZBX_DO_MIN;
else
{
SET_MSG_RESULT(result, zbx_strdup(NULL, "Invalid third parameter."));
return SYSINFO_RET_FAIL;
}
proccomm = get_rparam(request, 3);
while (0 < getprocs64(&procentry, (int)sizeof(struct procentry64), NULL, 0, &pid, 1))
{
if (NULL != procname && '\0' != *procname && 0 != strcmp(procname, procentry.pi_comm))
continue;
if (NULL != usrinfo && usrinfo->pw_uid != procentry.pi_uid)
continue;
if (NULL != proccomm && '\0' != *proccomm && SUCCEED != check_procargs(&procentry, proccomm))
continue;
value = procentry.pi_size;
value <<= 12; /* number of pages to bytes */
if (0 == proccount++)
{
memsize = value;
}
else
{
if (ZBX_DO_MAX == do_task)
memsize = MAX(memsize, value);
else if (ZBX_DO_MIN == do_task)
memsize = MIN(memsize, value);
else
memsize += value;
}
}
if (ZBX_DO_AVG == do_task)
SET_DBL_RESULT(result, 0 == proccount ? 0 : memsize / (double)proccount);
else
SET_UI64_RESULT(result, memsize);
return SYSINFO_RET_OK;
}