X-Git-Url: https://git.octo.it/?a=blobdiff_plain;f=src%2Fprocesses.c;h=c700ee63e4acbe6b560dfe9c563ae57129ada7da;hb=4d769ad2f6ec65834978aee356335ff507ac6e1f;hp=63c3c0e526fb6c2bc36dcbc44e5b264494aa5188;hpb=79963d13c1884d1d92667cc502ad20758b084a12;p=collectd.git

diff --git a/src/processes.c b/src/processes.c
index 63c3c0e5..c700ee63 100644
--- a/src/processes.c
+++ b/src/processes.c
@@ -159,9 +159,10 @@
 #endif
 #endif
 
-typedef struct procstat_entry_s {
+#define PROCSTAT_NAME_LEN 256
+typedef struct process_entry_s {
   unsigned long id;
-  unsigned long age;
+  char name[PROCSTAT_NAME_LEN];
 
   unsigned long num_proc;
   unsigned long num_lwp;
@@ -171,13 +172,9 @@ typedef struct procstat_entry_s {
   unsigned long vmem_code;
   unsigned long stack_size;
 
-  unsigned long vmem_minflt;
-  unsigned long vmem_majflt;
   derive_t vmem_minflt_counter;
   derive_t vmem_majflt_counter;
 
-  unsigned long cpu_user;
-  unsigned long cpu_system;
   derive_t cpu_user_counter;
   derive_t cpu_system_counter;
 
@@ -186,14 +183,26 @@ typedef struct procstat_entry_s {
   derive_t io_wchar;
   derive_t io_syscr;
   derive_t io_syscw;
+  _Bool has_io;
 
   derive_t cswitch_vol;
   derive_t cswitch_invol;
+  _Bool has_cswitch;
+} process_entry_t;
+
+typedef struct procstat_entry_s {
+  unsigned long id;
+  unsigned long age;
+
+  derive_t vmem_minflt_counter;
+  derive_t vmem_majflt_counter;
+
+  derive_t cpu_user_counter;
+  derive_t cpu_system_counter;
 
   struct procstat_entry_s *next;
 } procstat_entry_t;
 
-#define PROCSTAT_NAME_LEN 256
 typedef struct procstat {
   char name[PROCSTAT_NAME_LEN];
 #if HAVE_REGEX_H
@@ -229,6 +238,7 @@ typedef struct procstat {
 
 static procstat_t *list_head_g = NULL;
 
+static _Bool want_init = 1;
 static _Bool report_ctx_switch = 0;
 
 #if HAVE_THREAD_INFO
@@ -241,6 +251,7 @@ static mach_msg_type_number_t pset_list_len;
 
 #elif KERNEL_LINUX
 static long pagesize_g;
+static void ps_fill_details(const procstat_t *ps, process_entry_t *entry);
 /* #endif KERNEL_LINUX */
 
 #elif HAVE_LIBKVM_GETPROCS &&                                                  \
@@ -361,39 +372,40 @@ static int ps_list_match(const char *name, const char *cmdline,
   return (0);
 } /* int ps_list_match */
 
-static void ps_update_counter(_Bool init, derive_t *group_counter,
-                              derive_t *curr_counter, unsigned long *curr_value,
-                              derive_t new_counter, unsigned long new_value) {
-  if (init) {
-    *curr_value = new_value;
-    *curr_counter += new_value;
-    *group_counter += new_value;
+static void ps_update_counter(derive_t *group_counter, derive_t *curr_counter,
+                              derive_t new_counter) {
+  unsigned long curr_value;
+
+  if (want_init) {
+    *curr_counter = new_counter;
     return;
   }
 
   if (new_counter < *curr_counter)
-    *curr_value = new_counter + (ULONG_MAX - *curr_counter);
+    curr_value = new_counter + (ULONG_MAX - *curr_counter);
   else
-    *curr_value = new_counter - *curr_counter;
+    curr_value = new_counter - *curr_counter;
 
   *curr_counter = new_counter;
-  *group_counter += *curr_value;
+  *group_counter += curr_value;
 }
 
 /* add process entry to 'instances' of process 'name' (or refresh it) */
 static void ps_list_add(const char *name, const char *cmdline,
-                        procstat_entry_t *entry) {
+                        process_entry_t *entry) {
   procstat_entry_t *pse;
 
   if (entry->id == 0)
     return;
 
   for (procstat_t *ps = list_head_g; ps != NULL; ps = ps->next) {
-    _Bool want_init;
-
     if ((ps_list_match(name, cmdline, ps)) == 0)
       continue;
 
+#if KERNEL_LINUX
+    ps_fill_details(ps, entry);
+#endif
+
     for (pse = ps->instances; pse != NULL; pse = pse->next)
       if ((pse->id == entry->id) || (pse->next == NULL))
         break;
@@ -415,52 +427,33 @@ static void ps_list_add(const char *name, const char *cmdline,
     }
 
     pse->age = 0;
-    pse->num_proc = entry->num_proc;
-    pse->num_lwp = entry->num_lwp;
-    pse->vmem_size = entry->vmem_size;
-    pse->vmem_rss = entry->vmem_rss;
-    pse->vmem_data = entry->vmem_data;
-    pse->vmem_code = entry->vmem_code;
-    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;
-    pse->cswitch_vol = entry->cswitch_vol;
-    pse->cswitch_invol = entry->cswitch_invol;
-
-    ps->num_proc += pse->num_proc;
-    ps->num_lwp += pse->num_lwp;
-    ps->vmem_size += pse->vmem_size;
-    ps->vmem_rss += pse->vmem_rss;
-    ps->vmem_data += pse->vmem_data;
-    ps->vmem_code += pse->vmem_code;
-    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);
-
-    ps->cswitch_vol += ((pse->cswitch_vol == -1) ? 0 : pse->cswitch_vol);
-    ps->cswitch_invol += ((pse->cswitch_invol == -1) ? 0 : pse->cswitch_invol);
-
-    want_init =
-        (entry->vmem_minflt_counter == 0) && (entry->vmem_majflt_counter == 0);
-    ps_update_counter(want_init, &ps->vmem_minflt_counter,
-                      &pse->vmem_minflt_counter, &pse->vmem_minflt,
-                      entry->vmem_minflt_counter, entry->vmem_minflt);
-    ps_update_counter(want_init, &ps->vmem_majflt_counter,
-                      &pse->vmem_majflt_counter, &pse->vmem_majflt,
-                      entry->vmem_majflt_counter, entry->vmem_majflt);
-
-    want_init =
-        (entry->cpu_user_counter == 0) && (entry->cpu_system_counter == 0);
-    ps_update_counter(want_init, &ps->cpu_user_counter, &pse->cpu_user_counter,
-                      &pse->cpu_user, entry->cpu_user_counter, entry->cpu_user);
-    ps_update_counter(want_init, &ps->cpu_system_counter,
-                      &pse->cpu_system_counter, &pse->cpu_system,
-                      entry->cpu_system_counter, entry->cpu_system);
+
+    ps->num_proc += entry->num_proc;
+    ps->num_lwp += entry->num_lwp;
+    ps->vmem_size += entry->vmem_size;
+    ps->vmem_rss += entry->vmem_rss;
+    ps->vmem_data += entry->vmem_data;
+    ps->vmem_code += entry->vmem_code;
+    ps->stack_size += entry->stack_size;
+
+    ps->io_rchar += ((entry->io_rchar == -1) ? 0 : entry->io_rchar);
+    ps->io_wchar += ((entry->io_wchar == -1) ? 0 : entry->io_wchar);
+    ps->io_syscr += ((entry->io_syscr == -1) ? 0 : entry->io_syscr);
+    ps->io_syscw += ((entry->io_syscw == -1) ? 0 : entry->io_syscw);
+
+    ps->cswitch_vol += ((entry->cswitch_vol == -1) ? 0 : entry->cswitch_vol);
+    ps->cswitch_invol +=
+        ((entry->cswitch_invol == -1) ? 0 : entry->cswitch_invol);
+
+    ps_update_counter(&ps->vmem_minflt_counter, &pse->vmem_minflt_counter,
+                      entry->vmem_minflt_counter);
+    ps_update_counter(&ps->vmem_majflt_counter, &pse->vmem_majflt_counter,
+                      entry->vmem_majflt_counter);
+
+    ps_update_counter(&ps->cpu_user_counter, &pse->cpu_user_counter,
+                      entry->cpu_user_counter);
+    ps_update_counter(&ps->cpu_system_counter, &pse->cpu_system_counter,
+                      entry->cpu_system_counter);
   }
 }
 
@@ -621,14 +614,10 @@ static int ps_init(void) {
 
 /* submit global state (e.g.: qty of zombies, running, etc..) */
 static void ps_submit_state(const char *state, double value) {
-  value_t values[1];
   value_list_t vl = VALUE_LIST_INIT;
 
-  values[0].gauge = value;
-
-  vl.values = values;
+  vl.values = &(value_t){.gauge = value};
   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, "ps_state", sizeof(vl.type));
@@ -639,12 +628,10 @@ static void ps_submit_state(const char *state, double value) {
 
 /* submit info about specific process (e.g.: memory taken, cpu usage, etc..) */
 static void ps_submit_proc_list(procstat_t *ps) {
-  value_t values[2];
   value_list_t vl = VALUE_LIST_INIT;
+  value_t values[2];
 
   vl.values = values;
-  vl.values_len = 2;
-  sstrncpy(vl.host, hostname_g, sizeof(vl.host));
   sstrncpy(vl.plugin, "processes", sizeof(vl.plugin));
   sstrncpy(vl.plugin_instance, ps->name, sizeof(vl.plugin_instance));
 
@@ -738,14 +725,10 @@ static void ps_submit_proc_list(procstat_t *ps) {
 
 #if KERNEL_LINUX || KERNEL_SOLARIS
 static void ps_submit_fork_rate(derive_t value) {
-  value_t values[1];
   value_list_t vl = VALUE_LIST_INIT;
 
-  values[0].derive = value;
-
-  vl.values = values;
+  vl.values = &(value_t){.derive = value};
   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));
@@ -757,7 +740,7 @@ static void ps_submit_fork_rate(derive_t value) {
 
 /* ------- additional functions for KERNEL_LINUX/HAVE_THREAD_INFO ------- */
 #if KERNEL_LINUX
-static procstat_t *ps_read_tasks_status(long pid, procstat_t *ps) {
+static int ps_read_tasks_status(process_entry_t *ps) {
   char dirname[64];
   DIR *dh;
   char filename[64];
@@ -769,11 +752,11 @@ static procstat_t *ps_read_tasks_status(long pid, procstat_t *ps) {
   char *fields[8];
   int numfields;
 
-  ssnprintf(dirname, sizeof(dirname), "/proc/%li/task", pid);
+  ssnprintf(dirname, sizeof(dirname), "/proc/%li/task", ps->id);
 
   if ((dh = opendir(dirname)) == NULL) {
     DEBUG("Failed to open directory `%s'", dirname);
-    return (NULL);
+    return (-1);
   }
 
   while ((ent = readdir(dh)) != NULL) {
@@ -784,7 +767,7 @@ static procstat_t *ps_read_tasks_status(long pid, procstat_t *ps) {
 
     tpid = ent->d_name;
 
-    ssnprintf(filename, sizeof(filename), "/proc/%li/task/%s/status", pid,
+    ssnprintf(filename, sizeof(filename), "/proc/%li/task/%s/status", ps->id,
               tpid);
     if ((fh = fopen(filename, "r")) == NULL) {
       DEBUG("Failed to open file `%s'", filename);
@@ -827,11 +810,11 @@ static procstat_t *ps_read_tasks_status(long pid, procstat_t *ps) {
   ps->cswitch_vol = cswitch_vol;
   ps->cswitch_invol = cswitch_invol;
 
-  return (ps);
+  return (0);
 } /* int *ps_read_tasks_status */
 
 /* Read data from /proc/pid/status */
-static procstat_t *ps_read_status(long pid, procstat_t *ps) {
+static int ps_read_status(long pid, process_entry_t *ps) {
   FILE *fh;
   char buffer[1024];
   char filename[64];
@@ -844,7 +827,7 @@ static procstat_t *ps_read_status(long pid, procstat_t *ps) {
 
   ssnprintf(filename, sizeof(filename), "/proc/%li/status", pid);
   if ((fh = fopen(filename, "r")) == NULL)
-    return (NULL);
+    return (-1);
 
   while (fgets(buffer, sizeof(buffer), fh) != NULL) {
     unsigned long tmp;
@@ -884,10 +867,10 @@ static procstat_t *ps_read_status(long pid, procstat_t *ps) {
   if (threads != 0)
     ps->num_lwp = threads;
 
-  return (ps);
-} /* procstat_t *ps_read_vmem */
+  return (0);
+} /* int *ps_read_status */
 
-static procstat_t *ps_read_io(long pid, procstat_t *ps) {
+static int ps_read_io(process_entry_t *ps) {
   FILE *fh;
   char buffer[1024];
   char filename[64];
@@ -895,9 +878,9 @@ static procstat_t *ps_read_io(long pid, procstat_t *ps) {
   char *fields[8];
   int numfields;
 
-  ssnprintf(filename, sizeof(filename), "/proc/%li/io", pid);
+  ssnprintf(filename, sizeof(filename), "/proc/%li/io", ps->id);
   if ((fh = fopen(filename, "r")) == NULL)
-    return (NULL);
+    return (-1);
 
   while (fgets(buffer, sizeof(buffer), fh) != NULL) {
     derive_t *val = NULL;
@@ -933,11 +916,35 @@ static procstat_t *ps_read_io(long pid, procstat_t *ps) {
     char errbuf[1024];
     WARNING("processes: fclose: %s", sstrerror(errno, errbuf, sizeof(errbuf)));
   }
+  return (0);
+} /* int ps_read_io (...) */
 
-  return (ps);
-} /* procstat_t *ps_read_io */
+static void ps_fill_details(const procstat_t *ps, process_entry_t *entry) {
+  if (entry->has_io == 0 && ps_read_io(entry) != 0) {
+    /* no io data */
+    entry->io_rchar = -1;
+    entry->io_wchar = -1;
+    entry->io_syscr = -1;
+    entry->io_syscw = -1;
+
+    DEBUG("ps_read_io: not get io data for pid %li", entry->id);
+  }
+  entry->has_io = 1;
 
-static int ps_read_process(long pid, procstat_t *ps, char *state) {
+  if (report_ctx_switch) {
+    if (entry->has_cswitch == 0 && ps_read_tasks_status(entry) != 0) {
+      entry->cswitch_vol = -1;
+      entry->cswitch_invol = -1;
+
+      DEBUG("ps_read_tasks_status: not get context "
+            "switch data for pid %li",
+            entry->id);
+    }
+    entry->has_cswitch = 1;
+  }
+} /* void ps_fill_details (...) */
+
+static int ps_read_process(long pid, process_entry_t *ps, char *state) {
   char filename[64];
   char buffer[1024];
 
@@ -959,8 +966,6 @@ static int ps_read_process(long pid, procstat_t *ps, char *state) {
 
   ssize_t status;
 
-  memset(ps, 0, sizeof(procstat_t));
-
   ssnprintf(filename, sizeof(filename), "/proc/%li/stat", pid);
 
   status = read_file_contents(filename, buffer, sizeof(buffer) - 1);
@@ -1015,7 +1020,7 @@ static int ps_read_process(long pid, procstat_t *ps, char *state) {
     ps->num_proc = 0;
   } else {
     ps->num_lwp = strtoul(fields[17], /* endptr = */ NULL, /* base = */ 10);
-    if ((ps_read_status(pid, ps)) == NULL) {
+    if ((ps_read_status(pid, ps)) != 0) {
       /* No VMem data */
       ps->vmem_data = -1;
       ps->vmem_code = -1;
@@ -1060,27 +1065,6 @@ static int ps_read_process(long 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 %li", pid);
-  }
-
-  if (report_ctx_switch) {
-    if ((ps_read_tasks_status(pid, ps)) == NULL) {
-      ps->cswitch_vol = -1;
-      ps->cswitch_invol = -1;
-
-      DEBUG("ps_read_tasks_status: not get context "
-            "switch data for pid %li",
-            pid);
-    }
-  }
-
   /* success */
   return (0);
 } /* int ps_read_process (...) */
@@ -1252,7 +1236,7 @@ static char *ps_get_cmdline(long pid,
  * The values for input and ouput chars are calculated "by hand"
  * Added a few "solaris" specific process states as well
  */
-static int ps_read_process(long pid, procstat_t *ps, char *state) {
+static int ps_read_process(long pid, process_entry_t *ps, char *state) {
   char filename[64];
   char f_psinfo[64], f_usage[64];
   char *buffer;
@@ -1457,7 +1441,7 @@ static int ps_read(void) {
   int blocked = 0;
 
   procstat_t *ps;
-  procstat_entry_t pse;
+  process_entry_t pse;
 
   ps_list_reset();
 
@@ -1670,8 +1654,7 @@ static int ps_read(void) {
   char cmdline[CMDLINE_BUFFER_SIZE];
 
   int status;
-  procstat_t ps;
-  procstat_entry_t pse;
+  process_entry_t pse;
   char state;
 
   running = sleeping = zombies = stopped = paging = blocked = 0;
@@ -1690,42 +1673,15 @@ static int ps_read(void) {
     if ((pid = atol(ent->d_name)) < 1)
       continue;
 
-    status = ps_read_process(pid, &ps, &state);
+    memset(&pse, 0, sizeof(pse));
+    pse.id = pid;
+
+    status = ps_read_process(pid, &pse, &state);
     if (status != 0) {
       DEBUG("ps_read_process failed: %i", status);
       continue;
     }
 
-    memset(&pse, 0, sizeof(pse));
-    pse.id = pid;
-    pse.age = 0;
-
-    pse.num_proc = ps.num_proc;
-    pse.num_lwp = ps.num_lwp;
-    pse.vmem_size = ps.vmem_size;
-    pse.vmem_rss = ps.vmem_rss;
-    pse.vmem_data = ps.vmem_data;
-    pse.vmem_code = ps.vmem_code;
-    pse.stack_size = ps.stack_size;
-
-    pse.vmem_minflt = 0;
-    pse.vmem_minflt_counter = ps.vmem_minflt_counter;
-    pse.vmem_majflt = 0;
-    pse.vmem_majflt_counter = ps.vmem_majflt_counter;
-
-    pse.cpu_user = 0;
-    pse.cpu_user_counter = ps.cpu_user_counter;
-    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;
-
-    pse.cswitch_vol = ps.cswitch_vol;
-    pse.cswitch_invol = ps.cswitch_invol;
-
     switch (state) {
     case 'R':
       running++;
@@ -1747,8 +1703,8 @@ static int ps_read(void) {
       break;
     }
 
-    ps_list_add(ps.name, ps_get_cmdline(pid, ps.name, cmdline, sizeof(cmdline)),
-                &pse);
+    ps_list_add(pse.name,
+                ps_get_cmdline(pid, pse.name, cmdline, sizeof(cmdline)), &pse);
   }
 
   closedir(proc);
@@ -1781,7 +1737,7 @@ static int ps_read(void) {
   struct kinfo_proc *proc_ptr = NULL;
   int count; /* returns number of processes */
 
-  procstat_entry_t pse;
+  process_entry_t pse;
 
   ps_list_reset();
 
@@ -1831,8 +1787,8 @@ static int ps_read(void) {
         }
       } /* if (process has argument list) */
 
+      memset(&pse, 0, sizeof(pse));
       pse.id = procs[i].ki_pid;
-      pse.age = 0;
 
       pse.num_proc = 1;
       pse.num_lwp = procs[i].ki_numthreads;
@@ -1842,13 +1798,9 @@ static int ps_read(void) {
       pse.vmem_data = procs[i].ki_dsize * pagesize;
       pse.vmem_code = procs[i].ki_tsize * pagesize;
       pse.stack_size = procs[i].ki_ssize * pagesize;
-      pse.vmem_minflt = 0;
       pse.vmem_minflt_counter = procs[i].ki_rusage.ru_minflt;
-      pse.vmem_majflt = 0;
       pse.vmem_majflt_counter = procs[i].ki_rusage.ru_majflt;
 
-      pse.cpu_user = 0;
-      pse.cpu_system = 0;
       pse.cpu_user_counter = 0;
       pse.cpu_system_counter = 0;
       /*
@@ -1932,12 +1884,12 @@ static int ps_read(void) {
   struct kinfo_proc *proc_ptr = NULL;
   int count; /* returns number of processes */
 
-  procstat_entry_t pse;
+  process_entry_t pse;
 
   ps_list_reset();
 
   /* Open the kvm interface, get a descriptor */
-  kd = kvm_open(NULL, NULL, NULL, 0, errbuf);
+  kd = kvm_openfiles(NULL, NULL, NULL, KVM_NO_FILES, errbuf);
   if (kd == NULL) {
     ERROR("processes plugin: Cannot open kvm interface: %s", errbuf);
     return (0);
@@ -1984,7 +1936,6 @@ static int ps_read(void) {
 
       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 ? */
@@ -1994,13 +1945,9 @@ static int ps_read(void) {
       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 =
@@ -2070,7 +2017,7 @@ static int ps_read(void) {
   pid_t pindex = 0;
   int nprocs;
 
-  procstat_entry_t pse;
+  process_entry_t pse;
 
   ps_list_reset();
   while ((nprocs = getprocs64(procentry, sizeof(struct procentry64),
@@ -2110,8 +2057,9 @@ static int ps_read(void) {
         }
       }
 
+      memset(&pse, 0, sizeof(pse));
+
       pse.id = procentry[i].pi_pid;
-      pse.age = 0;
       pse.num_lwp = procentry[i].pi_thcount;
       pse.num_proc = 1;
 
@@ -2148,19 +2096,15 @@ static int ps_read(void) {
           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;
@@ -2227,8 +2171,7 @@ static int ps_read(void) {
 
   while ((ent = readdir(proc)) != NULL) {
     long pid;
-    struct procstat ps;
-    procstat_entry_t pse;
+    process_entry_t pse;
     char *endptr;
 
     if (!isdigit((int)ent->d_name[0]))
@@ -2238,42 +2181,15 @@ static int ps_read(void) {
     if (*endptr != 0) /* value didn't completely parse as a number */
       continue;
 
-    status = ps_read_process(pid, &ps, &state);
+    memset(&pse, 0, sizeof(pse));
+    pse.id = pid;
+
+    status = ps_read_process(pid, &pse, &state);
     if (status != 0) {
       DEBUG("ps_read_process failed: %i", status);
       continue;
     }
 
-    memset(&pse, 0, sizeof(pse));
-    pse.id = pid;
-    pse.age = 0;
-
-    pse.num_proc = ps.num_proc;
-    pse.num_lwp = ps.num_lwp;
-    pse.vmem_size = ps.vmem_size;
-    pse.vmem_rss = ps.vmem_rss;
-    pse.vmem_data = ps.vmem_data;
-    pse.vmem_code = ps.vmem_code;
-    pse.stack_size = ps.stack_size;
-
-    pse.vmem_minflt = 0;
-    pse.vmem_minflt_counter = ps.vmem_minflt_counter;
-    pse.vmem_majflt = 0;
-    pse.vmem_majflt_counter = ps.vmem_majflt_counter;
-
-    pse.cpu_user = 0;
-    pse.cpu_user_counter = ps.cpu_user_counter;
-    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;
-
-    pse.cswitch_vol = -1;
-    pse.cswitch_invol = -1;
-
     switch (state) {
     case 'R':
       running++;
@@ -2301,8 +2217,8 @@ static int ps_read(void) {
       break;
     }
 
-    ps_list_add(ps.name, ps_get_cmdline(pid, ps.name, cmdline, sizeof(cmdline)),
-                &pse);
+    ps_list_add(pse.name,
+                ps_get_cmdline(pid, pse.name, cmdline, sizeof(cmdline)), &pse);
   } /* while(readdir) */
   closedir(proc);
 
@@ -2321,6 +2237,8 @@ static int ps_read(void) {
   read_fork_rate();
 #endif /* KERNEL_SOLARIS */
 
+  want_init = 0;
+
   return (0);
 } /* int ps_read */