*
* Authors:
* Lyonel Vincent <lyonel at ezix.org>
- * Florian octo Forster <octo at verplant.org>
+ * Florian octo Forster <octo at collectd.org>
* Oleg King <king2 at kaluga.ru>
* Sebastian Harl <sh at tokkee.org>
* Andrés J. Díaz <ajdiaz at connectical.com>
# endif
/* #endif KERNEL_LINUX */
-#elif HAVE_LIBKVM_GETPROCS && HAVE_STRUCT_KINFO_PROC_FREEBSD
+#elif HAVE_LIBKVM_GETPROCS && (HAVE_STRUCT_KINFO_PROC_FREEBSD || HAVE_STRUCT_KINFO_PROC_OPENBSD)
# include <kvm.h>
# include <sys/param.h>
# include <sys/sysctl.h>
# include <sys/user.h>
# include <sys/proc.h>
-/* #endif HAVE_LIBKVM_GETPROCS && HAVE_STRUCT_KINFO_PROC_FREEBSD */
+/* #endif HAVE_LIBKVM_GETPROCS && (HAVE_STRUCT_KINFO_PROC_FREEBSD || HAVE_STRUCT_KINFO_PROC_OPENBSD) */
#elif HAVE_PROCINFO_H
# include <procinfo.h>
# include <kstat.h>
#endif
-#ifndef ARG_MAX
-# define ARG_MAX 4096
+#ifndef CMDLINE_BUFFER_SIZE
+# if defined(ARG_MAX) && (ARG_MAX < 4096)
+# define CMDLINE_BUFFER_SIZE ARG_MAX
+# else
+# define CMDLINE_BUFFER_SIZE 4096
+# endif
#endif
typedef struct procstat_entry_s
static long pagesize_g;
/* #endif KERNEL_LINUX */
-#elif HAVE_LIBKVM_GETPROCS && HAVE_STRUCT_KINFO_PROC_FREEBSD
+#elif HAVE_LIBKVM_GETPROCS && (HAVE_STRUCT_KINFO_PROC_FREEBSD || HAVE_STRUCT_KINFO_PROC_OPENBSD)
static int pagesize;
-/* #endif HAVE_LIBKVM_GETPROCS && HAVE_STRUCT_KINFO_PROC_FREEBSD */
+/* #endif HAVE_LIBKVM_GETPROCS && (HAVE_STRUCT_KINFO_PROC_FREEBSD || HAVE_STRUCT_KINFO_PROC_OPENBSD) */
#elif HAVE_PROCINFO_H
static struct procentry64 procentry[MAXPROCENTRY];
"`ProcessMatch' with the same name. "
"All but the first setting will be "
"ignored.");
+#if HAVE_REGEX_H
sfree (new->re);
+#endif
sfree (new);
return;
}
pagesize_g, CONFIG_HZ);
/* #endif KERNEL_LINUX */
-#elif HAVE_LIBKVM_GETPROCS && HAVE_STRUCT_KINFO_PROC_FREEBSD
+#elif HAVE_LIBKVM_GETPROCS && (HAVE_STRUCT_KINFO_PROC_FREEBSD || HAVE_STRUCT_KINFO_PROC_OPENBSD)
pagesize = getpagesize();
-/* #endif HAVE_LIBKVM_GETPROCS && HAVE_STRUCT_KINFO_PROC_FREEBSD */
+/* #endif HAVE_LIBKVM_GETPROCS && (HAVE_STRUCT_KINFO_PROC_FREEBSD || HAVE_STRUCT_KINFO_PROC_OPENBSD) */
#elif HAVE_PROCINFO_H
pagesize = getpagesize();
/* ------- additional functions for KERNEL_LINUX/HAVE_THREAD_INFO ------- */
#if KERNEL_LINUX
-static int ps_read_tasks (int pid)
+static int ps_read_tasks (long pid)
{
char dirname[64];
DIR *dh;
struct dirent *ent;
int count = 0;
- ssnprintf (dirname, sizeof (dirname), "/proc/%i/task", pid);
+ ssnprintf (dirname, sizeof (dirname), "/proc/%li/task", pid);
if ((dh = opendir (dirname)) == NULL)
{
} /* int *ps_read_tasks */
/* Read advanced virtual memory data from /proc/pid/status */
-static procstat_t *ps_read_vmem (int pid, procstat_t *ps)
+static procstat_t *ps_read_vmem (long pid, procstat_t *ps)
{
FILE *fh;
char buffer[1024];
char *fields[8];
int numfields;
- ssnprintf (filename, sizeof (filename), "/proc/%i/status", pid);
+ ssnprintf (filename, sizeof (filename), "/proc/%li/status", pid);
if ((fh = fopen (filename, "r")) == NULL)
return (NULL);
return (ps);
} /* procstat_t *ps_read_vmem */
-static procstat_t *ps_read_io (int pid, procstat_t *ps)
+static procstat_t *ps_read_io (long pid, procstat_t *ps)
{
FILE *fh;
char buffer[1024];
char *fields[8];
int numfields;
- ssnprintf (filename, sizeof (filename), "/proc/%i/io", pid);
+ ssnprintf (filename, sizeof (filename), "/proc/%li/io", pid);
if ((fh = fopen (filename, "r")) == NULL)
return (NULL);
return (ps);
} /* procstat_t *ps_read_io */
-int ps_read_process (int pid, procstat_t *ps, char *state)
+static int ps_read_process (long pid, procstat_t *ps, char *state)
{
char filename[64];
char buffer[1024];
memset (ps, 0, sizeof (procstat_t));
- ssnprintf (filename, sizeof (filename), "/proc/%i/stat", pid);
+ ssnprintf (filename, sizeof (filename), "/proc/%li/stat", pid);
buffer_len = read_file_contents (filename,
buffer, sizeof(buffer) - 1);
fields_len = strsplit (buffer_ptr, fields, STATIC_ARRAY_SIZE (fields));
if (fields_len < 22)
{
- DEBUG ("processes plugin: ps_read_process (pid = %i):"
+ DEBUG ("processes plugin: ps_read_process (pid = %li):"
" `%s' has only %i fields..",
- (int) pid, filename, fields_len);
+ pid, filename, fields_len);
return (-1);
}
/* Leave the rest at zero if this is only a zombi */
if (ps->num_proc == 0)
{
- DEBUG ("processes plugin: This is only a zombi: pid = %i; "
+ DEBUG ("processes plugin: This is only a zombie: pid = %li; "
"name = %s;", pid, ps->name);
return (0);
}
/* No VMem data */
ps->vmem_data = -1;
ps->vmem_code = -1;
- DEBUG("ps_read_process: did not get vmem data for pid %i",pid);
+ DEBUG("ps_read_process: did not get vmem data for pid %li", pid);
}
ps->cpu_user_counter = cpu_user_counter;
ps->io_syscr = -1;
ps->io_syscw = -1;
- DEBUG("ps_read_process: not get io data for pid %i",pid);
+ DEBUG("ps_read_process: not get io data for pid %li", pid);
}
/* success */
return (0);
} /* int ps_read_process (...) */
-static char *ps_get_cmdline (pid_t pid, char *name, char *buf, size_t buf_len)
+static char *ps_get_cmdline (long pid, char *name, char *buf, size_t buf_len)
{
char *buf_ptr;
size_t len;
if ((pid < 1) || (NULL == buf) || (buf_len < 2))
return NULL;
- ssnprintf (file, sizeof (file), "/proc/%u/cmdline",
- (unsigned int) pid);
+ ssnprintf (file, sizeof (file), "/proc/%li/cmdline", pid);
errno = 0;
fd = open (file, O_RDONLY);
return buf;
} /* char *ps_get_cmdline (...) */
-static int read_fork_rate ()
+static int read_fork_rate (void)
{
FILE *proc_stat;
char buffer[1024];
#endif /*KERNEL_LINUX */
#if KERNEL_SOLARIS
-static const char *ps_get_cmdline (long pid, /* {{{ */
- char *buffer, size_t buffer_size)
+static char *ps_get_cmdline (long pid, char *name __attribute__((unused)), /* {{{ */
+ char *buffer, size_t buffer_size)
{
char path[PATH_MAX];
psinfo_t info;
struct dirent *ent;
DIR *proc;
- int pid;
+ long pid;
- char cmdline[ARG_MAX];
+ char cmdline[CMDLINE_BUFFER_SIZE];
int status;
procstat_t ps;
if (!isdigit (ent->d_name[0]))
continue;
- if ((pid = atoi (ent->d_name)) < 1)
+ if ((pid = atol (ent->d_name)) < 1)
continue;
status = ps_read_process (pid, &ps, &state);
continue;
}
+ memset (&pse, 0, sizeof (pse));
pse.id = pid;
pse.age = 0;
* filter out threads (duplicate PID entries). */
if ((proc_ptr == NULL) || (proc_ptr->ki_pid != procs[i].ki_pid))
{
- char cmdline[ARG_MAX] = "";
+ char cmdline[CMDLINE_BUFFER_SIZE] = "";
_Bool have_cmdline = 0;
proc_ptr = &(procs[i]);
ps_submit_proc_list (ps_ptr);
/* #endif HAVE_LIBKVM_GETPROCS && HAVE_STRUCT_KINFO_PROC_FREEBSD */
+#elif HAVE_LIBKVM_GETPROCS && HAVE_STRUCT_KINFO_PROC_OPENBSD
+ int running = 0;
+ int sleeping = 0;
+ int zombies = 0;
+ int stopped = 0;
+ int onproc = 0;
+ int idle = 0;
+ int dead = 0;
+
+ kvm_t *kd;
+ char errbuf[1024];
+ struct kinfo_proc *procs; /* array of processes */
+ struct kinfo_proc *proc_ptr = NULL;
+ int count; /* returns number of processes */
+ int i;
+
+ procstat_t *ps_ptr;
+ procstat_entry_t pse;
+
+ ps_list_reset ();
+
+ /* Open the kvm interface, get a descriptor */
+ kd = kvm_open (NULL, NULL, NULL, 0, errbuf);
+ if (kd == NULL)
+ {
+ ERROR ("processes plugin: Cannot open kvm interface: %s",
+ errbuf);
+ return (0);
+ }
+
+ /* Get the list of processes. */
+ procs = kvm_getprocs(kd, KERN_PROC_ALL, 0, sizeof(struct kinfo_proc), &count);
+ if (procs == NULL)
+ {
+ ERROR ("processes plugin: Cannot get kvm processes list: %s",
+ kvm_geterr(kd));
+ kvm_close (kd);
+ return (0);
+ }
+
+ /* Iterate through the processes in kinfo_proc */
+ for (i = 0; i < count; i++)
+ {
+ /* Create only one process list entry per _process_, i.e.
+ * filter out threads (duplicate PID entries). */
+ if ((proc_ptr == NULL) || (proc_ptr->p_pid != procs[i].p_pid))
+ {
+ char cmdline[CMDLINE_BUFFER_SIZE] = "";
+ _Bool have_cmdline = 0;
+
+ proc_ptr = &(procs[i]);
+ /* Don't probe zombie processes */
+ if (!P_ZOMBIE(proc_ptr))
+ {
+ char **argv;
+ int argc;
+ int status;
+
+ /* retrieve the arguments */
+ argv = kvm_getargv (kd, proc_ptr, /* nchr = */ 0);
+ argc = 0;
+ if ((argv != NULL) && (argv[0] != NULL))
+ {
+ while (argv[argc] != NULL)
+ argc++;
+
+ status = strjoin (cmdline, sizeof (cmdline), argv, argc, " ");
+ if (status < 0)
+ WARNING ("processes plugin: Command line did not fit into buffer.");
+ else
+ have_cmdline = 1;
+ }
+ } /* if (process has argument list) */
+
+ memset (&pse, 0, sizeof (pse));
+ pse.id = procs[i].p_pid;
+ pse.age = 0;
+
+ pse.num_proc = 1;
+ pse.num_lwp = 1; /* XXX: accumulate p_tid values for a single p_pid ? */
+
+ pse.vmem_rss = procs[i].p_vm_rssize * pagesize;
+ pse.vmem_data = procs[i].p_vm_dsize * pagesize;
+ pse.vmem_code = procs[i].p_vm_tsize * pagesize;
+ pse.stack_size = procs[i].p_vm_ssize * pagesize;
+ pse.vmem_size = pse.stack_size + pse.vmem_code + pse.vmem_data;
+ pse.vmem_minflt = 0;
+ pse.vmem_minflt_counter = procs[i].p_uru_minflt;
+ pse.vmem_majflt = 0;
+ pse.vmem_majflt_counter = procs[i].p_uru_majflt;
+
+ pse.cpu_user = 0;
+ pse.cpu_system = 0;
+ pse.cpu_user_counter = procs[i].p_uutime_usec +
+ (1000000lu * procs[i].p_uutime_sec);
+ pse.cpu_system_counter = procs[i].p_ustime_usec +
+ (1000000lu * procs[i].p_ustime_sec);
+
+ /* no I/O data */
+ pse.io_rchar = -1;
+ pse.io_wchar = -1;
+ pse.io_syscr = -1;
+ pse.io_syscw = -1;
+
+ pse.cswitch_vol = -1;
+ pse.cswitch_invol = -1;
+
+ ps_list_add (procs[i].p_comm, have_cmdline ? cmdline : NULL, &pse);
+
+ switch (procs[i].p_stat)
+ {
+ case SSTOP: stopped++; break;
+ case SSLEEP: sleeping++; break;
+ case SRUN: running++; break;
+ case SIDL: idle++; break;
+ case SONPROC: onproc++; break;
+ case SDEAD: dead++; break;
+ case SZOMB: zombies++; break;
+ }
+ } /* if ((proc_ptr == NULL) || (proc_ptr->p_pid != procs[i].p_pid)) */
+ }
+
+ kvm_close(kd);
+
+ ps_submit_state ("running", running);
+ ps_submit_state ("sleeping", sleeping);
+ ps_submit_state ("zombies", zombies);
+ ps_submit_state ("stopped", stopped);
+ ps_submit_state ("onproc", onproc);
+ ps_submit_state ("idle", idle);
+ ps_submit_state ("dead", dead);
+
+ for (ps_ptr = list_head_g; ps_ptr != NULL; ps_ptr = ps_ptr->next)
+ ps_submit_proc_list (ps_ptr);
+/* #endif HAVE_LIBKVM_GETPROCS && HAVE_STRUCT_KINFO_PROC_OPENBSD */
+
#elif HAVE_PROCINFO_H
/* AIX */
int running = 0;
continue;
}
+ memset (&pse, 0, sizeof (pse));
pse.id = pid;
pse.age = 0;
pse.io_syscr = ps.io_syscr;
pse.io_syscw = ps.io_syscw;
+ pse.cswitch_vol = -1;
+ pse.cswitch_invol = -1;
+
switch (state)
{
case 'R': running++; break;
ps_list_add (ps.name,
- ps_get_cmdline (pid, cmdline, sizeof (cmdline)),
+ ps_get_cmdline (pid, ps.name, cmdline, sizeof (cmdline)),
&pse);
} /* while(readdir) */
closedir (proc);
projects / collectd.git / blobdiff