X-Git-Url: https://git.octo.it/?a=blobdiff_plain;f=src%2Fprocesses.c;h=f2eb0a34a0156613725ea0be87688b155d862c40;hb=9988d61c84dfff5d04ddf48f4b93f6c9449cdc41;hp=2e44018e8c16ae219e720ce39f68888de5af1cff;hpb=cfb86a0f119d0ee0e72a920ba1251bb0350cf08b;p=collectd.git diff --git a/src/processes.c b/src/processes.c index 2e44018e..f2eb0a34 100644 --- a/src/processes.c +++ b/src/processes.c @@ -1,8 +1,11 @@ /** * collectd - src/processes.c - * Copyright (C) 2005 Lyonel Vincent - * Copyright (C) 2006-2008 Florian Forster (Mach code) - * Copyright (C) 2008 Oleg King + * Copyright (C) 2005 Lyonel Vincent + * Copyright (C) 2006-2008 Florian octo Forster + * Copyright (C) 2008 Oleg King + * Copyright (C) 2009 Sebastian Harl + * Copyright (C) 2009 Andrés J. Díaz + * Copyright (C) 2009 Manuel Sanmartin * * This program is free software; you can redistribute it and/or modify it * under the terms of the GNU General Public License as published by the @@ -23,6 +26,8 @@ * Florian octo Forster * Oleg King * Sebastian Harl + * Andrés J. Díaz + * Manuel Sanmartin **/ #include "collectd.h" @@ -85,14 +90,22 @@ # endif /* #endif KERNEL_LINUX */ -#elif HAVE_LIBKVM_GETPROCS +#elif HAVE_LIBKVM_GETPROCS && HAVE_STRUCT_KINFO_PROC_FREEBSD # include +# include +# include # include # include -# if HAVE_SYS_SYSCTL_H -# include -# endif -/* #endif HAVE_LIBKVM_GETPROCS */ +/* #endif HAVE_LIBKVM_GETPROCS && HAVE_STRUCT_KINFO_PROC_FREEBSD */ + +#elif HAVE_PROCINFO_H +# include +# include + +#define MAXPROCENTRY 32 +#define MAXTHRDENTRY 16 +#define MAXARGLN 1024 +/* #endif HAVE_PROCINFO_H */ #else # error "No applicable input method." @@ -136,6 +149,12 @@ typedef struct procstat_entry_s unsigned long cpu_user_counter; unsigned long cpu_system_counter; + /* io data */ + derive_t io_rchar; + derive_t io_wchar; + derive_t io_syscr; + derive_t io_syscw; + struct procstat_entry_s *next; } procstat_entry_t; @@ -159,6 +178,12 @@ typedef struct procstat unsigned long cpu_user_counter; unsigned long cpu_system_counter; + /* io data */ + derive_t io_rchar; + derive_t io_wchar; + derive_t io_syscr; + derive_t io_syscw; + struct procstat *next; struct procstat_entry_s *instances; } procstat_t; @@ -177,9 +202,21 @@ static mach_msg_type_number_t pset_list_len; static long pagesize_g; /* #endif KERNEL_LINUX */ -#elif HAVE_LIBKVM_GETPROCS +#elif HAVE_LIBKVM_GETPROCS && HAVE_STRUCT_KINFO_PROC_FREEBSD /* no global variables */ -#endif /* HAVE_LIBKVM_GETPROCS */ +/* #endif HAVE_LIBKVM_GETPROCS && HAVE_STRUCT_KINFO_PROC_FREEBSD */ + +#elif HAVE_PROCINFO_H +static struct procentry64 procentry[MAXPROCENTRY]; +static struct thrdentry64 thrdentry[MAXTHRDENTRY]; +static int pagesize; + +#ifndef _AIXVERSION_610 +int getprocs64 (void *procsinfo, int sizproc, void *fdsinfo, int sizfd, pid_t *index, int count); +int getthrds64( pid_t, void *, int, tid64_t *, int ); +#endif +int getargs (struct procentry64 *processBuffer, int bufferLen, char *argsBuffer, int argsLen); +#endif /* HAVE_PROCINFO_H */ /* put name of process from config to list_head_g tree list_head_g is a list of 'procstat_t' structs with @@ -225,13 +262,13 @@ static void ps_list_register (const char *name, const char *regexp) ERROR ("processes plugin: ps_list_register: " "Regular expression \"%s\" found in config " "file, but support for regular expressions " - "has been dispabled at compile time.", + "has been disabled at compile time.", regexp); sfree (new); return; } #endif - + for (ptr = list_head_g; ptr != NULL; ptr = ptr->next) { if (strcmp (ptr->name, name) == 0) @@ -307,13 +344,13 @@ static void ps_list_add (const char *name, const char *cmdline, procstat_entry_t if ((pse == NULL) || (pse->id != entry->id)) { procstat_entry_t *new; - + new = (procstat_entry_t *) malloc (sizeof (procstat_entry_t)); if (new == NULL) return; memset (new, 0, sizeof (procstat_entry_t)); new->id = entry->id; - + if (pse == NULL) ps->instances = new; else @@ -328,6 +365,10 @@ static void ps_list_add (const char *name, const char *cmdline, procstat_entry_t pse->vmem_size = entry->vmem_size; pse->vmem_rss = entry->vmem_rss; pse->stack_size = entry->stack_size; + pse->io_rchar = entry->io_rchar; + pse->io_wchar = entry->io_wchar; + pse->io_syscr = entry->io_syscr; + pse->io_syscw = entry->io_syscw; ps->num_proc += pse->num_proc; ps->num_lwp += pse->num_lwp; @@ -335,6 +376,11 @@ static void ps_list_add (const char *name, const char *cmdline, procstat_entry_t ps->vmem_rss += pse->vmem_rss; ps->stack_size += pse->stack_size; + ps->io_rchar += ((pse->io_rchar == -1)?0:pse->io_rchar); + ps->io_wchar += ((pse->io_wchar == -1)?0:pse->io_wchar); + ps->io_syscr += ((pse->io_syscr == -1)?0:pse->io_syscr); + ps->io_syscw += ((pse->io_syscw == -1)?0:pse->io_syscw); + if ((entry->vmem_minflt_counter == 0) && (entry->vmem_majflt_counter == 0)) { @@ -356,7 +402,7 @@ static void ps_list_add (const char *name, const char *cmdline, procstat_entry_t pse->vmem_minflt = entry->vmem_minflt_counter - pse->vmem_minflt_counter; } pse->vmem_minflt_counter = entry->vmem_minflt_counter; - + if (entry->vmem_majflt_counter < pse->vmem_majflt_counter) { pse->vmem_majflt = entry->vmem_majflt_counter @@ -393,7 +439,7 @@ static void ps_list_add (const char *name, const char *cmdline, procstat_entry_t pse->cpu_user = entry->cpu_user_counter - pse->cpu_user_counter; } pse->cpu_user_counter = entry->cpu_user_counter; - + if (entry->cpu_system_counter < pse->cpu_system_counter) { pse->cpu_system = entry->cpu_system_counter @@ -425,6 +471,10 @@ static void ps_list_reset (void) ps->vmem_size = 0; ps->vmem_rss = 0; ps->stack_size = 0; + ps->io_rchar = -1; + ps->io_wchar = -1; + ps->io_syscr = -1; + ps->io_syscw = -1; pse_prev = NULL; pse = ps->instances; @@ -536,9 +586,13 @@ static int ps_init (void) pagesize_g, CONFIG_HZ); /* #endif KERNEL_LINUX */ -#elif HAVE_LIBKVM_GETPROCS +#elif HAVE_LIBKVM_GETPROCS && HAVE_STRUCT_KINFO_PROC_FREEBSD /* no initialization */ -#endif /* HAVE_LIBKVM_GETPROCS */ +/* #endif HAVE_LIBKVM_GETPROCS && HAVE_STRUCT_KINFO_PROC_FREEBSD */ + +#elif HAVE_PROCINFO_H + pagesize = getpagesize(); +#endif /* HAVE_PROCINFO_H */ return (0); } /* int ps_init */ @@ -607,76 +661,117 @@ static void ps_submit_proc_list (procstat_t *ps) vl.values_len = 2; plugin_dispatch_values (&vl); + if ( (ps->io_rchar != -1) && (ps->io_wchar != -1) ) + { + sstrncpy (vl.type, "ps_disk_octets", sizeof (vl.type)); + vl.values[0].derive = ps->io_rchar; + vl.values[1].derive = ps->io_wchar; + vl.values_len = 2; + plugin_dispatch_values (&vl); + } + + if ( (ps->io_syscr != -1) && (ps->io_syscw != -1) ) + { + sstrncpy (vl.type, "ps_disk_ops", sizeof (vl.type)); + vl.values[0].derive = ps->io_syscr; + vl.values[1].derive = ps->io_syscw; + vl.values_len = 2; + plugin_dispatch_values (&vl); + } + DEBUG ("name = %s; num_proc = %lu; num_lwp = %lu; vmem_rss = %lu; " "vmem_minflt_counter = %lu; vmem_majflt_counter = %lu; " - "cpu_user_counter = %lu; cpu_system_counter = %lu;", + "cpu_user_counter = %lu; cpu_system_counter = %lu; " + "io_rchar = %"PRIi64"; io_wchar = %"PRIi64"; " + "io_syscr = %"PRIi64"; io_syscw = %"PRIi64";", ps->name, ps->num_proc, ps->num_lwp, ps->vmem_rss, ps->vmem_minflt_counter, ps->vmem_majflt_counter, - ps->cpu_user_counter, ps->cpu_system_counter); + ps->cpu_user_counter, ps->cpu_system_counter, + ps->io_rchar, ps->io_wchar, ps->io_syscr, ps->io_syscw); } /* void ps_submit_proc_list */ /* ------- additional functions for KERNEL_LINUX/HAVE_THREAD_INFO ------- */ #if KERNEL_LINUX -static int *ps_read_tasks (int pid) +static int ps_read_tasks (int pid) { - int *list = NULL; - int list_size = 1; /* size of allocated space, in elements */ - int list_len = 0; /* number of currently used elements */ - char dirname[64]; DIR *dh; struct dirent *ent; + int count = 0; ssnprintf (dirname, sizeof (dirname), "/proc/%i/task", pid); if ((dh = opendir (dirname)) == NULL) { DEBUG ("Failed to open directory `%s'", dirname); - return (NULL); + return (-1); } while ((ent = readdir (dh)) != NULL) { - if (!isdigit (ent->d_name[0])) + if (!isdigit ((int) ent->d_name[0])) continue; + else + count++; + } + closedir (dh); - if ((list_len + 1) >= list_size) - { - int *new_ptr; - int new_size = 2 * list_size; - /* Comes in sizes: 2, 4, 8, 16, ... */ + return ((count >= 1) ? count : 1); +} /* int *ps_read_tasks */ - new_ptr = (int *) realloc (list, (size_t) (sizeof (int) * new_size)); - if (new_ptr == NULL) - { - if (list != NULL) - free (list); - ERROR ("processes plugin: " - "Failed to allocate more memory."); - return (NULL); - } +static procstat_t *ps_read_io (int pid, procstat_t *ps) +{ + FILE *fh; + char buffer[1024]; + char filename[64]; - list = new_ptr; - list_size = new_size; + char *fields[8]; + int numfields; - memset (list + list_len, 0, sizeof (int) * (list_size - list_len)); - } + ssnprintf (filename, sizeof (filename), "/proc/%i/io", pid); + if ((fh = fopen (filename, "r")) == NULL) + return (NULL); - list[list_len] = atoi (ent->d_name); - if (list[list_len] != 0) - list_len++; - } + while (fgets (buffer, 1024, fh) != NULL) + { + derive_t *val = NULL; + long long tmp; + char *endptr; + + if (strncasecmp (buffer, "rchar:", 6) == 0) + val = &(ps->io_rchar); + else if (strncasecmp (buffer, "wchar:", 6) == 0) + val = &(ps->io_wchar); + else if (strncasecmp (buffer, "syscr:", 6) == 0) + val = &(ps->io_syscr); + else if (strncasecmp (buffer, "syscw:", 6) == 0) + val = &(ps->io_syscw); + else + continue; - closedir (dh); + numfields = strsplit (buffer, fields, 8); - if (list_len == 0) - return (NULL); + if (numfields < 2) + continue; - assert (list_len < list_size); - assert (list[list_len] == 0); + errno = 0; + endptr = NULL; + tmp = strtoll (fields[1], &endptr, /* base = */ 10); + if ((errno != 0) || (endptr == fields[1])) + *val = -1; + else + *val = (derive_t) tmp; + } /* while (fgets) */ - return (list); -} /* int *ps_read_tasks */ + if (fclose (fh)) + { + char errbuf[1024]; + WARNING ("processes: fclose: %s", + sstrerror (errno, errbuf, sizeof (errbuf))); + } + + return (ps); +} /* procstat_t *ps_read_io */ int ps_read_process (int pid, procstat_t *ps, char *state) { @@ -686,7 +781,6 @@ int ps_read_process (int pid, procstat_t *ps, char *state) char *fields[64]; char fields_len; - int *tasks; int i; int ppid; @@ -736,21 +830,14 @@ int ps_read_process (int pid, procstat_t *ps, char *state) ps->num_lwp = 0; ps->num_proc = 0; } - else if ((tasks = ps_read_tasks (pid)) == NULL) - { - /* Kernel 2.4 or so */ - ps->num_lwp = 1; - ps->num_proc = 1; - } else { - ps->num_lwp = 0; + if ( (ps->num_lwp = ps_read_tasks (pid)) == -1 ) + { + /* returns -1 => kernel 2.4 */ + ps->num_lwp = 1; + } ps->num_proc = 1; - for (i = 0; tasks[i] != 0; i++) - ps->num_lwp++; - - free (tasks); - tasks = NULL; } /* Leave the rest at zero if this is only a zombi */ @@ -788,6 +875,17 @@ int ps_read_process (int pid, procstat_t *ps, char *state) ps->vmem_rss = (unsigned long) vmem_rss; ps->stack_size = (unsigned long) stack_size; + if ( (ps_read_io (pid, ps)) == NULL) + { + /* no io data */ + ps->io_rchar = -1; + ps->io_wchar = -1; + ps->io_syscr = -1; + ps->io_syscw = -1; + + DEBUG("ps_read_process: not get io data for pid %i",pid); + } + /* success */ return (0); } /* int ps_read_process (...) */ @@ -881,6 +979,70 @@ static char *ps_get_cmdline (pid_t pid, char *name, char *buf, size_t buf_len) } return buf; } /* char *ps_get_cmdline (...) */ + +static unsigned long read_fork_rate () +{ + FILE *proc_stat; + char buf[1024]; + unsigned long result = 0; + int numfields; + char *fields[3]; + + proc_stat = fopen("/proc/stat", "r"); + if (proc_stat == NULL) { + char errbuf[1024]; + ERROR ("processes plugin: fopen (/proc/stat) failed: %s", + sstrerror (errno, errbuf, sizeof (errbuf))); + return ULONG_MAX; + } + + while (fgets (buf, sizeof(buf), proc_stat) != NULL) + { + char *endptr; + + numfields = strsplit(buf, fields, STATIC_ARRAY_SIZE (fields)); + if (numfields != 2) + continue; + + if (strcmp ("processes", fields[0]) != 0) + continue; + + errno = 0; + endptr = NULL; + result = strtoul(fields[1], &endptr, 10); + if ((endptr == fields[1]) || (errno != 0)) { + ERROR ("processes plugin: Cannot parse fork rate: %s", + fields[1]); + result = ULONG_MAX; + break; + } + + break; + } + + fclose(proc_stat); + + return result; +} + +static void ps_submit_fork_rate (unsigned long value) +{ + value_t values[1]; + value_list_t vl = VALUE_LIST_INIT; + + values[0].derive = (derive_t) value; + + vl.values = values; + vl.values_len = 1; + sstrncpy (vl.host, hostname_g, sizeof (vl.host)); + sstrncpy (vl.plugin, "processes", sizeof (vl.plugin)); + sstrncpy (vl.plugin_instance, "", sizeof (vl.plugin_instance)); + sstrncpy (vl.type, "fork_rate", sizeof (vl.type)); + sstrncpy (vl.type_instance, "", sizeof (vl.type_instance)); + + plugin_dispatch_values (&vl); +} + #endif /* KERNEL_LINUX */ #if HAVE_THREAD_INFO @@ -1203,6 +1365,8 @@ static int ps_read (void) procstat_entry_t pse; char state; + unsigned long fork_rate; + procstat_t *ps_ptr; running = sleeping = zombies = stopped = paging = blocked = 0; @@ -1250,6 +1414,11 @@ static int ps_read (void) pse.cpu_system = 0; pse.cpu_system_counter = ps.cpu_system_counter; + pse.io_rchar = ps.io_rchar; + pse.io_wchar = ps.io_wchar; + pse.io_syscr = ps.io_syscr; + pse.io_syscw = ps.io_syscw; + switch (state) { case 'R': running++; break; @@ -1276,9 +1445,13 @@ static int ps_read (void) for (ps_ptr = list_head_g; ps_ptr != NULL; ps_ptr = ps_ptr->next) ps_submit_proc_list (ps_ptr); + + fork_rate = read_fork_rate(); + if (fork_rate != ULONG_MAX) + ps_submit_fork_rate(fork_rate); /* #endif KERNEL_LINUX */ -#elif HAVE_LIBKVM_GETPROCS +#elif HAVE_LIBKVM_GETPROCS && HAVE_STRUCT_KINFO_PROC_FREEBSD int running = 0; int sleeping = 0; int zombies = 0; @@ -1374,6 +1547,12 @@ static int ps_read (void) * 1000 + procs[i].ki_rusage.ru_stime.tv_usec; + /* no io data */ + pse.io_rchar = -1; + pse.io_wchar = -1; + pse.io_syscr = -1; + pse.io_syscw = -1; + switch (procs[i].ki_stat) { case SSTOP: stopped++; break; @@ -1400,7 +1579,133 @@ static int ps_read (void) for (ps_ptr = list_head_g; ps_ptr != NULL; ps_ptr = ps_ptr->next) ps_submit_proc_list (ps_ptr); -#endif /* HAVE_LIBKVM_GETPROCS */ +/* #endif HAVE_LIBKVM_GETPROCS && HAVE_STRUCT_KINFO_PROC_FREEBSD */ + +#elif HAVE_PROCINFO_H + /* AIX */ + int running = 0; + int sleeping = 0; + int zombies = 0; + int stopped = 0; + int paging = 0; + int blocked = 0; + + pid_t pindex = 0; + int nprocs; + + procstat_t *ps; + procstat_entry_t pse; + + ps_list_reset (); + while ((nprocs = getprocs64 (procentry, sizeof(struct procentry64), + /* fdsinfo = */ NULL, sizeof(struct fdsinfo64), + &pindex, MAXPROCENTRY)) > 0) + { + int i; + + for (i = 0; i < nprocs; i++) + { + tid64_t thindex; + int nthreads; + char arglist[MAXARGLN+1]; + char *cargs; + char *cmdline; + + if (procentry[i].pi_state == SNONE) continue; + /* if (procentry[i].pi_state == SZOMB) FIXME */ + + cmdline = procentry[i].pi_comm; + cargs = procentry[i].pi_comm; + if ( procentry[i].pi_flags & SKPROC ) + { + if (procentry[i].pi_pid == 0) + cmdline = "swapper"; + cargs = cmdline; + } + else + { + if (getargs(&procentry[i], sizeof(struct procentry64), arglist, MAXARGLN) >= 0) + { + int n; + + n = -1; + while (++n < MAXARGLN) + { + if (arglist[n] == '\0') + { + if (arglist[n+1] == '\0') + break; + arglist[n] = ' '; + } + } + cargs = arglist; + } + } + + pse.id = procentry[i].pi_pid; + pse.age = 0; + pse.num_lwp = procentry[i].pi_thcount; + pse.num_proc = 1; + + thindex=0; + while ((nthreads = getthrds64(procentry[i].pi_pid, + thrdentry, sizeof(struct thrdentry64), + &thindex, MAXTHRDENTRY)) > 0) + { + int j; + + for (j=0; j< nthreads; j++) + { + switch (thrdentry[j].ti_state) + { + /* case TSNONE: break; */ + case TSIDL: blocked++; break; /* FIXME is really blocked */ + case TSRUN: running++; break; + case TSSLEEP: sleeping++; break; + case TSSWAP: paging++; break; + case TSSTOP: stopped++; break; + case TSZOMB: zombies++; break; + } + } + if (nthreads < MAXTHRDENTRY) + break; + } + + pse.cpu_user = 0; + /* tv_usec is nanosec ??? */ + pse.cpu_user_counter = procentry[i].pi_ru.ru_utime.tv_sec * 1000000 + + procentry[i].pi_ru.ru_utime.tv_usec / 1000; + + pse.cpu_system = 0; + /* tv_usec is nanosec ??? */ + pse.cpu_system_counter = procentry[i].pi_ru.ru_stime.tv_sec * 1000000 + + procentry[i].pi_ru.ru_stime.tv_usec / 1000; + + pse.vmem_minflt = 0; + pse.vmem_minflt_counter = procentry[i].pi_minflt; + pse.vmem_majflt = 0; + pse.vmem_majflt_counter = procentry[i].pi_majflt; + + pse.vmem_size = procentry[i].pi_tsize + procentry[i].pi_dvm * pagesize; + pse.vmem_rss = (procentry[i].pi_drss + procentry[i].pi_trss) * pagesize; + pse.stack_size = 0; + + ps_list_add (cmdline, cargs, &pse); + } /* for (i = 0 .. nprocs) */ + + if (nprocs < MAXPROCENTRY) + break; + } /* while (getprocs64() > 0) */ + ps_submit_state ("running", running); + ps_submit_state ("sleeping", sleeping); + ps_submit_state ("zombies", zombies); + ps_submit_state ("stopped", stopped); + ps_submit_state ("paging", paging); + ps_submit_state ("blocked", blocked); + + for (ps = list_head_g; ps != NULL; ps = ps->next) + ps_submit_proc_list (ps); +#endif /* HAVE_PROCINFO_H */ return (0); } /* int ps_read */