X-Git-Url: https://git.octo.it/?a=blobdiff_plain;f=src%2Fprocesses.c;h=f102a6c905f8d224b0f23ab090b4e612b500bc6d;hb=aee1cc1a20b3e7f131835fe5d3ba0f5a51cb6731;hp=20842518a4e4f5f815ac9afc2f0d898b6aeed3e9;hpb=cb6fbadd9ff71988de4eaa0218007ef0916c7755;p=collectd.git

diff --git a/src/processes.c b/src/processes.c
index 20842518..f102a6c9 100644
--- a/src/processes.c
+++ b/src/processes.c
@@ -112,8 +112,29 @@
 /* #endif HAVE_PROCINFO_H */
 
 #elif KERNEL_SOLARIS
+/* Hack: Avoid #error when building a 32-bit binary with
+ * _FILE_OFFSET_BITS=64. There is a reason for this #error, as one
+ * of the structures in <sys/procfs.h> uses an off_t, but that
+ * isn't relevant to our usage of procfs. */
+#if !defined(_LP64) && _FILE_OFFSET_BITS == 64
+#  define SAVE_FOB_64
+#  undef _FILE_OFFSET_BITS
+#endif
+
 # include <procfs.h>
+
+#ifdef SAVE_FOB_64
+#  define _FILE_OFFSET_BITS 64
+#  undef SAVE_FOB_64
+#endif
+
+# include <sys/user.h>
 # include <dirent.h>
+
+#ifndef MAXCOMLEN
+#  define MAXCOMLEN 16
+#endif
+
 /* #endif KERNEL_SOLARIS */
 
 #else
@@ -223,12 +244,12 @@ static int pagesize;
 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);
+int getargs (void *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
-   processes names we want to watch */
+ * list_head_g is a list of 'procstat_t' structs with
+ * processes names we want to watch */
 static void ps_list_register (const char *name, const char *regexp)
 {
 	procstat_t *new;
@@ -261,6 +282,7 @@ static void ps_list_register (const char *name, const char *regexp)
 		{
 			DEBUG ("ProcessMatch: compiling the regular expression \"%s\" failed.", regexp);
 			sfree(new->re);
+			sfree(new);
 			return;
 		}
 	}
@@ -286,7 +308,9 @@ static void ps_list_register (const char *name, const char *regexp)
 					"`ProcessMatch' with the same name. "
 					"All but the first setting will be "
 					"ignored.");
+#if HAVE_REGEX_H
 			sfree (new->re);
+#endif
 			sfree (new);
 			return;
 		}
@@ -528,6 +552,12 @@ static int ps_config (oconfig_item_t *ci)
 {
 	int i;
 
+#if KERNEL_LINUX
+	const size_t max_procname_len = 15;
+#elif KERNEL_SOLARIS || KERNEL_FREEBSD
+	const size_t max_procname_len = MAXCOMLEN -1;
+#endif
+
 	for (i = 0; i < ci->children_num; ++i) {
 		oconfig_item_t *c = ci->children + i;
 
@@ -548,6 +578,15 @@ static int ps_config (oconfig_item_t *ci)
 						c->children_num, c->values[0].value.string);
 			}
 
+#if KERNEL_LINUX || KERNEL_SOLARIS || KERNEL_FREEBSD
+			if (strlen (c->values[0].value.string) > max_procname_len) {
+				WARNING ("processes plugin: this platform has a %zu character limit "
+						"to process names. The `Process \"%s\"' option will "
+						"not work as expected.",
+						max_procname_len, c->values[0].value.string);
+			}
+#endif
+
 			ps_list_register (c->values[0].value.string, NULL);
 		}
 		else if (strcasecmp (c->key, "ProcessMatch") == 0)
@@ -723,7 +762,7 @@ static void ps_submit_proc_list (procstat_t *ps)
 	}
 
 	DEBUG ("name = %s; num_proc = %lu; num_lwp = %lu; "
-                        "vmem_size = %lu; vmem_rss = %lu; vmem_data = %lu; "
+			"vmem_size = %lu; vmem_rss = %lu; vmem_data = %lu; "
 			"vmem_code = %lu; "
 			"vmem_minflt_counter = %"PRIi64"; vmem_majflt_counter = %"PRIi64"; "
 			"cpu_user_counter = %"PRIi64"; cpu_system_counter = %"PRIi64"; "
@@ -737,16 +776,36 @@ static void ps_submit_proc_list (procstat_t *ps)
 			ps->io_rchar, ps->io_wchar, ps->io_syscr, ps->io_syscw);
 } /* void ps_submit_proc_list */
 
+#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_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 || KERNEL_SOLARIS*/
+
 /* ------- 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)
 	{
@@ -767,7 +826,7 @@ static int ps_read_tasks (int pid)
 } /* 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];
@@ -778,7 +837,7 @@ static procstat_t *ps_read_vmem (int pid, procstat_t *ps)
 	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);
 
@@ -791,7 +850,7 @@ static procstat_t *ps_read_vmem (int pid, procstat_t *ps)
 			continue;
 
 		numfields = strsplit (buffer, fields,
-                                      STATIC_ARRAY_SIZE (fields));
+				STATIC_ARRAY_SIZE (fields));
 
 		if (numfields < 2)
 			continue;
@@ -829,7 +888,7 @@ static procstat_t *ps_read_vmem (int pid, procstat_t *ps)
 	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];
@@ -838,7 +897,7 @@ static procstat_t *ps_read_io (int pid, procstat_t *ps)
 	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);
 
@@ -884,7 +943,7 @@ static procstat_t *ps_read_io (int pid, procstat_t *ps)
 	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];
@@ -907,7 +966,7 @@ int ps_read_process (int pid, procstat_t *ps, char *state)
 
 	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);
@@ -952,9 +1011,9 @@ int ps_read_process (int pid, procstat_t *ps, char *state)
 	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);
 	}
 
@@ -978,7 +1037,7 @@ int ps_read_process (int pid, procstat_t *ps, char *state)
 	/* 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);
 	}
@@ -1009,7 +1068,7 @@ int ps_read_process (int pid, procstat_t *ps, char *state)
 		/* 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;
@@ -1026,14 +1085,14 @@ int ps_read_process (int pid, procstat_t *ps, char *state)
 		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;
@@ -1046,8 +1105,7 @@ static char *ps_get_cmdline (pid_t pid, char *name, char *buf, size_t buf_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);
@@ -1128,92 +1186,77 @@ 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 ()
+static int read_fork_rate (void)
 {
 	FILE *proc_stat;
-	char buf[1024];
-	unsigned long result = 0;
-	int numfields;
-	char *fields[3];
+	char buffer[1024];
+	value_t value;
+	_Bool value_valid = 0;
 
-	proc_stat = fopen("/proc/stat", "r");
-	if (proc_stat == NULL) {
+	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;
+		return (-1);
 	}
 
-	while (fgets (buf, sizeof(buf), proc_stat) != NULL)
+	while (fgets (buffer, sizeof (buffer), proc_stat) != NULL)
 	{
-		char *endptr;
+		int status;
+		char *fields[3];
+		int fields_num;
 
-		numfields = strsplit(buf, fields, STATIC_ARRAY_SIZE (fields));
-		if (numfields != 2)
+		fields_num = strsplit (buffer, fields,
+				STATIC_ARRAY_SIZE (fields));
+		if (fields_num != 2)
 			continue;
 
 		if (strcmp ("processes", fields[0]) != 0)
 			continue;
 
-		errno = 0;
-		endptr = NULL;
-		result = strtoul(fields[1], &endptr, /* base = */ 10);
-		if ((endptr == fields[1]) || (errno != 0)) {
-			ERROR ("processes plugin: Cannot parse fork rate: %s",
-					fields[1]);
-			result = ULONG_MAX;
-			break;
-		}
+		status = parse_value (fields[1], &value, DS_TYPE_DERIVE);
+		if (status == 0)
+			value_valid = 1;
 
 		break;
 	}
-
 	fclose(proc_stat);
 
-	return result;
-}
-#endif /*KERNEL_LINUX */
-
-#if KERNEL_LINUX || KERNEL_SOLARIS
-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));
+	if (!value_valid)
+		return (-1);
 
-	plugin_dispatch_values(&vl);
+	ps_submit_fork_rate (value.derive);
+	return (0);
 }
-#endif /* KERNEL_LINUX || KERNEL_SOLARIS*/
+#endif /*KERNEL_LINUX */
 
 #if KERNEL_SOLARIS
-static char *ps_get_cmdline(pid_t pid)
+static char *ps_get_cmdline (long pid, char *name __attribute__((unused)), /* {{{ */
+    char *buffer, size_t buffer_size)
 {
-	char f_psinfo[64];
-	char cmdline[80];
-	char *buffer = NULL;
-	psinfo_t *myInfo;
+	char path[PATH_MAX];
+	psinfo_t info;
+	int status;
 
-	snprintf(f_psinfo, sizeof (f_psinfo), "/proc/%i/psinfo", pid);
+	snprintf(path, sizeof (path), "/proc/%li/psinfo", pid);
 
-	buffer = (char *)malloc(sizeof (psinfo_t));
-	memset(buffer, 0, sizeof(psinfo_t));
-	read_file_contents(f_psinfo, buffer, sizeof (psinfo_t));
-	myInfo = (psinfo_t *) buffer;
+	status = read_file_contents (path, (void *) &info, sizeof (info));
+	if (status != sizeof (info))
+	{
+		ERROR ("processes plugin: Unexpected return value "
+				"while reading \"%s\": "
+				"Returned %i but expected %zu.",
+				path, status, buffer_size);
+		return (NULL);
+	}
 
-	sstrncpy(cmdline, myInfo->pr_psargs, sizeof (myInfo->pr_psargs));
+	info.pr_psargs[sizeof (info.pr_psargs) - 1] = 0;
+	sstrncpy (buffer, info.pr_psargs, buffer_size);
 
-	sfree(myInfo);
-	return strtok(cmdline, " ");
-}
+	return (buffer);
+} /* }}} int ps_get_cmdline */
 
 /*
  * Reads process information on the Solaris OS. The information comes mainly from
@@ -1221,22 +1264,19 @@ static char *ps_get_cmdline(pid_t 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(int pid, procstat_t *ps, char *state)
+static int ps_read_process(long pid, procstat_t *ps, char *state)
 {
-
 	char filename[64];
 	char f_psinfo[64], f_usage[64];
-	int i;
 	char *buffer;
 
-
 	pstatus_t *myStatus;
 	psinfo_t *myInfo;
 	prusage_t *myUsage;
 
-	snprintf(filename, sizeof (filename), "/proc/%i/status", pid);
-	snprintf(f_psinfo, sizeof (f_psinfo), "/proc/%i/psinfo", pid);
-	snprintf(f_usage, sizeof (f_usage), "/proc/%i/usage", pid);
+	snprintf(filename, sizeof (filename), "/proc/%li/status", pid);
+	snprintf(f_psinfo, sizeof (f_psinfo), "/proc/%li/psinfo", pid);
+	snprintf(f_usage, sizeof (f_usage), "/proc/%li/usage", pid);
 
 
 	buffer = malloc(sizeof (pstatus_t));
@@ -1260,6 +1300,10 @@ static int ps_read_process(int pid, procstat_t *ps, char *state)
 		ps->num_proc = 0;
 		ps->num_lwp = 0;
 		*state = (char) 'Z';
+
+		sfree(myStatus);
+		sfree(myInfo);
+		sfree(myUsage);
 		return (0);
 	} else {
 		ps->num_proc = 1;
@@ -1335,25 +1379,35 @@ static int ps_read_process(int pid, procstat_t *ps, char *state)
  * are retrieved from kstat (module cpu, name sys, class misc, stat nthreads).
  * The result is the sum for all the threads created on each cpu
  */
-static unsigned long read_fork_rate()
+static int read_fork_rate()
 {
 	extern kstat_ctl_t *kc;
 	kstat_t *ksp_chain = NULL;
-	unsigned long result = 0;
+	derive_t result = 0;
 
 	if (kc == NULL)
-		return ULONG_MAX;
-
-	for (ksp_chain = kc->kc_chain; ksp_chain != NULL;
-	     ksp_chain = ksp_chain->ks_next) {
-		if ((strncmp(ksp_chain->ks_module, "cpu", 3) == 0) &&
-		    (strncmp(ksp_chain->ks_name, "sys", 3) == 0) &&
-		    (strncmp(ksp_chain->ks_class, "misc", 4) == 0)) {
-			kstat_read(kc, ksp_chain, NULL);
-			result += get_kstat_value(ksp_chain, "nthreads");
+		return (-1);
+
+	for (ksp_chain = kc->kc_chain;
+			ksp_chain != NULL;
+			ksp_chain = ksp_chain->ks_next)
+	{
+		if ((strcmp (ksp_chain->ks_module, "cpu") == 0)
+				&& (strcmp (ksp_chain->ks_name, "sys") == 0)
+				&& (strcmp (ksp_chain->ks_class, "misc") == 0))
+		{
+			long long tmp;
+
+			kstat_read (kc, ksp_chain, NULL);
+
+			tmp = get_kstat_value(ksp_chain, "nthreads");
+			if (tmp != -1LL)
+				result += tmp;
 		}
 	}
-	return result;
+
+	ps_submit_fork_rate (result);
+	return (0);
 }
 #endif /* KERNEL_SOLARIS */
 
@@ -1672,7 +1726,7 @@ static int ps_read (void)
 
 	struct dirent *ent;
 	DIR           *proc;
-	int            pid;
+	long           pid;
 
 	char cmdline[ARG_MAX];
 
@@ -1681,8 +1735,6 @@ 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;
@@ -1701,7 +1753,7 @@ static int ps_read (void)
 		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);
@@ -1764,9 +1816,7 @@ 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);
+	read_fork_rate();
 /* #endif KERNEL_LINUX */
 
 #elif HAVE_LIBKVM_GETPROCS && HAVE_STRUCT_KINFO_PROC_FREEBSD
@@ -1779,10 +1829,10 @@ static int ps_read (void)
 	int wait     = 0;
 
 	kvm_t *kd;
-	char errbuf[1024];
-  	struct kinfo_proc *procs;          /* array of processes */
+	char errbuf[_POSIX2_LINE_MAX];
+	struct kinfo_proc *procs;          /* array of processes */
 	struct kinfo_proc *proc_ptr = NULL;
-  	int count;                         /* returns number of processes */
+	int count;                         /* returns number of processes */
 	int i;
 
 	procstat_t *ps_ptr;
@@ -1791,7 +1841,7 @@ static int ps_read (void)
 	ps_list_reset ();
 
 	/* Open the kvm interface, get a descriptor */
-	kd = kvm_open (NULL, NULL, NULL, 0, errbuf);
+	kd = kvm_openfiles (NULL, "/dev/null", NULL, 0, errbuf);
 	if (kd == NULL)
 	{
 		ERROR ("processes plugin: Cannot open kvm interface: %s",
@@ -1885,18 +1935,18 @@ static int ps_read (void)
 			pse.io_syscw = -1;
 
 			ps_list_add (procs[i].ki_comm, have_cmdline ? cmdline : NULL, &pse);
-		} /* if ((proc_ptr == NULL) || (proc_ptr->ki_pid != procs[i].ki_pid)) */
 
-		switch (procs[i].ki_stat)
-		{
-			case SSTOP: 	stopped++;	break;
-			case SSLEEP:	sleeping++;	break;
-			case SRUN:	running++;	break;
-			case SIDL:	idle++;		break;
-			case SWAIT:	wait++;		break;
-			case SLOCK:	blocked++;	break;
-			case SZOMB:	zombies++;	break;
-		}
+			switch (procs[i].ki_stat)
+			{
+				case SSTOP:	stopped++;	break;
+				case SSLEEP:	sleeping++;	break;
+				case SRUN:	running++;	break;
+				case SIDL:	idle++;		break;
+				case SWAIT:	wait++;		break;
+				case SLOCK:	blocked++;	break;
+				case SZOMB:	zombies++;	break;
+			}
+		} /* if ((proc_ptr == NULL) || (proc_ptr->ki_pid != procs[i].ki_pid)) */
 	}
 
 	kvm_close(kd);
@@ -1953,7 +2003,7 @@ static int ps_read (void)
 				if (procentry[i].pi_pid == 0)
 					cmdline = "swapper";
 				cargs = cmdline;
- 			}
+			}
 			else
 			{
 				if (getargs(&procentry[i], sizeof(struct procentry64), arglist, MAXARGLN) >= 0)
@@ -2049,10 +2099,10 @@ static int ps_read (void)
 
 #elif KERNEL_SOLARIS
 	/*
-         * The Solaris section adds a few more process states and removes some
-         * process states compared to linux. Most notably there is no "PAGING"
-         * and "BLOCKED" state for a process.  The rest is similar to the linux
-         * code.
+	 * The Solaris section adds a few more process states and removes some
+	 * process states compared to linux. Most notably there is no "PAGING"
+	 * and "BLOCKED" state for a process.  The rest is similar to the linux
+	 * code.
 	 */
 	int running = 0;
 	int sleeping = 0;
@@ -2062,46 +2112,52 @@ static int ps_read (void)
 	int daemon = 0;
 	int system = 0;
 	int orphan = 0;
-	unsigned long fork_rate;
+
 	struct dirent *ent;
 	DIR *proc;
-	int pid;
 
 	int status;
-	struct procstat ps;
-	procstat_entry_t pse;
 	procstat_t *ps_ptr;
 	char state;
 
-	ps_list_reset();
+	char cmdline[PRARGSZ];
 
+	ps_list_reset ();
 
-	proc = opendir("/proc");
-	if (proc == NULL) {
+	proc = opendir ("/proc");
+	if (proc == NULL)
 		return (-1);
-	}
 
-	while ((ent = readdir(proc)) != NULL) {
-		if (!isdigit(ent->d_name[0]))
+	while ((ent = readdir(proc)) != NULL)
+	{
+		long pid;
+		struct procstat ps;
+		procstat_entry_t pse;
+		char *endptr;
+
+		if (!isdigit ((int) ent->d_name[0]))
 			continue;
 
-		if ((pid = atoi(ent->d_name)) < 1)
+		pid = strtol (ent->d_name, &endptr, 10);
+		if (*endptr != 0) /* value didn't completely parse as a number */
 			continue;
 
-		status = ps_read_process(pid, &ps, &state);
-		if (status != 0) {
+		status = ps_read_process (pid, &ps, &state);
+		if (status != 0)
+		{
 			DEBUG("ps_read_process failed: %i", status);
 			continue;
 		}
+
 		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.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;
@@ -2119,48 +2175,38 @@ static int ps_read (void)
 		pse.io_syscr = ps.io_syscr;
 		pse.io_syscw = ps.io_syscw;
 
-		switch (state) {
-		case 'R': running++;
-			break;
-		case 'S': sleeping++;
-			break;
-		case 'E': detached++;
-			break;
-		case 'Z': zombies++;
-			break;
-		case 'T': stopped++;
-			break;
-		case 'A': daemon++;
-			break;
-		case 'Y': system++;
-			break;
-		case 'O': orphan++;
-			break;
+		switch (state)
+		{
+			case 'R': running++;  break;
+			case 'S': sleeping++; break;
+			case 'E': detached++; break;
+			case 'Z': zombies++;  break;
+			case 'T': stopped++;  break;
+			case 'A': daemon++;   break;
+			case 'Y': system++;   break;
+			case 'O': orphan++;   break;
 		}
 
-		ps_list_add(ps.name, ps_get_cmdline(pid), &pse);
 
-	} // while()
-	closedir(proc);
+		ps_list_add (ps.name,
+				ps_get_cmdline (pid, ps.name, cmdline, sizeof (cmdline)),
+				&pse);
+	} /* while(readdir) */
+	closedir (proc);
 
-	ps_submit_state("running", running);
-	ps_submit_state("sleeping", sleeping);
-	ps_submit_state("zombies", zombies);
-	ps_submit_state("stopped", stopped);
-	ps_submit_state("detached", detached);
-	ps_submit_state("daemon", daemon);
-	ps_submit_state("system", system);
-	ps_submit_state("orphan", orphan);
+	ps_submit_state ("running",  running);
+	ps_submit_state ("sleeping", sleeping);
+	ps_submit_state ("zombies",  zombies);
+	ps_submit_state ("stopped",  stopped);
+	ps_submit_state ("detached", detached);
+	ps_submit_state ("daemon",   daemon);
+	ps_submit_state ("system",   system);
+	ps_submit_state ("orphan",   orphan);
 
 	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);
-	}
+		ps_submit_proc_list (ps_ptr);
 
+	read_fork_rate();
 #endif /* KERNEL_SOLARIS */
 
 	return (0);