Use glibtop_warn_io_r () instead of glibtop_error_io_r ().

1998-10-31  Martin Baulig  <martin@home-of-linux.org>

	* *.c: Use glibtop_warn_io_r () instead of glibtop_error_io_r ().

	* proctime.c, prockernel.c, procargs.c: Don't call kvm_uread () if
	the /proc filesystem is not mounted.

sysdeps/freebsd/ChangeLog

@@ -1,3 +1,10 @@
+1998-10-31  Martin Baulig  <martin@home-of-linux.org>
+
+	* *.c: Use glibtop_warn_io_r () instead of glibtop_error_io_r ().
+
+	* proctime.c, prockernel.c, procargs.c: Don't call kvm_uread () if
+	the /proc filesystem is not mounted.
+
 1998-10-26  Martin Baulig  <martin@home-of-linux.org>
 
 	* netload.c: New file to get network load.

sysdeps/freebsd/cpu.c

@@ -45,10 +45,13 @@ static int mib [] = { CTL_KERN, KERN_CLOCKRATE };
 void
 glibtop_init_cpu_p (glibtop *server)
 {
-	server->sysdeps.cpu = _glibtop_sysdeps_cpu;
+	if (kvm_nlist (server->machine.kd, nlst) != 0) {
+		glibtop_warn_io_r (server, "kvm_nlist (cpu)");
+		return;
+	}
 
-	if (kvm_nlist (server->machine.kd, nlst) != 0)
+	/* Set this only if kvm_nlist () succeeded. */
-		glibtop_error_io_r (server, "kvm_nlist");
+	server->sysdeps.cpu = _glibtop_sysdeps_cpu;
 }
 
 /* Provides information about cpu usage. */
@@ -65,16 +68,22 @@ glibtop_get_cpu_p (glibtop *server, glibtop_cpu *buf)
 	
 	memset (buf, 0, sizeof (glibtop_cpu));
 
+	/* If this fails, the nlist may not be valid. */
+	if (server->sysdeps.cpu == 0)
+		return;
+
 	if (kvm_read (server->machine.kd, nlst [0].n_value,
-		      &cpts, sizeof (cpts)) != sizeof (cpts))
+		      &cpts, sizeof (cpts)) != sizeof (cpts)) {
-		glibtop_error_io_r (server, "kvm_read (cp_time)");
+		glibtop_warn_io_r (server, "kvm_read (cp_time)");
+		return;
+	}
 	
 	/* Get the clockrate data */
 	length = sizeof (struct clockinfo);
-	if (sysctl (mib, mib_length, &ci, &length, NULL, 0))
+	if (sysctl (mib, mib_length, &ci, &length, NULL, 0)) {
-		glibtop_error_io_r (server, "sysctl");
+		glibtop_warn_io_r (server, "sysctl");
-
+		return;
-	buf->flags = _glibtop_sysdeps_cpu;
+	}
 
 	/* set user time */
 	buf->user = cpts [CP_USER];
@@ -96,4 +105,7 @@ glibtop_get_cpu_p (glibtop *server, glibtop_cpu *buf)
 	/* set total */
 	buf->total = cpts [CP_USER] + cpts [CP_NICE]
 		+ cpts [CP_SYS] + cpts [CP_IDLE];
+
+	/* Set the flags last. */
+	buf->flags = _glibtop_sysdeps_cpu;
 }

sysdeps/freebsd/mem.c

@@ -63,10 +63,10 @@ glibtop_init_mem_p (glibtop *server)
 {
 	register int pagesize;
 
-	server->sysdeps.mem = _glibtop_sysdeps_mem;
+	if (kvm_nlist (server->machine.kd, nlst) != 0) {
-
+		glibtop_warn_io_r (server, "kvm_nlist (mem)");
-	if (kvm_nlist (server->machine.kd, nlst) != 0)
+		return;
-		glibtop_error_io_r (server, "kvm_nlist");
+	}
 
 	/* get the page size with "getpagesize" and calculate pageshift
 	 * from it */
@@ -79,6 +79,8 @@ glibtop_init_mem_p (glibtop *server)
 
 	/* we only need the amount of log(2)1024 for our conversion */
 	pageshift -= LOG1024;
+
+	server->sysdeps.mem = _glibtop_sysdeps_mem;
 }
 
 void
@@ -93,26 +95,32 @@ glibtop_get_mem_p (glibtop *server, glibtop_mem *buf)
 	
 	memset (buf, 0, sizeof (glibtop_mem));
 
+	if (server->sysdeps.mem == 0)
+		return;
+
 	/* [FIXME: On FreeBSD 2.2.6, sysctl () returns an incorrect
 	 *         value for `vmt.vm'. We use some code from Unix top
 	 *         here.] */
 
 	/* Get the data from sysctl */
 	length_vmt = sizeof (vmt);
-	if (sysctl (mib, 2, &vmt, &length_vmt, NULL, 0))
+	if (sysctl (mib, 2, &vmt, &length_vmt, NULL, 0)) {
-		glibtop_error_io_r (server, "sysctl");
+		glibtop_warn_io_r (server, "sysctl");
+		return;
+	}
 	
 	/* Get the data from kvm_* */
 	if (kvm_read (server->machine.kd, nlst[0].n_value,
-		      &vmm, sizeof (vmm)) != sizeof (vmm))
+		      &vmm, sizeof (vmm)) != sizeof (vmm)) {
-		glibtop_error_io_r (server, "kvm_read (cnt)");
+		glibtop_warn_io_r (server, "kvm_read (cnt)");
+		return;
+	}
 
 	if (kvm_read (server->machine.kd, nlst[1].n_value,
-		      &bufspace, sizeof (bufspace)) != sizeof (bufspace))
+		      &bufspace, sizeof (bufspace)) != sizeof (bufspace)) {
-		glibtop_error_io_r (server, "kvm_read (bufspace)");
+		glibtop_warn_io_r (server, "kvm_read (bufspace)");
-  
+		return;
-	/* Set the values to return */
+	}
-	buf->flags = _glibtop_sysdeps_mem;
   
 	/* convert memory stats to Kbytes */
 
@@ -125,18 +133,9 @@ glibtop_get_mem_p (glibtop *server, glibtop_mem *buf)
 
 	buf->buffer = (u_int64_t) bufspace;
 
-#if 0
-        if (swappgsin < 0) {
-	    memory_stats[5] = 0;
-	    memory_stats[6] = 0;
-	} else {
-	    memory_stats[5] = pagetok(((vmm.v_swappgsin - swappgsin)));
-	    memory_stats[6] = pagetok(((vmm.v_swappgsout - swappgsout)));
-	}
-        swappgsin = vmm.v_swappgsin;
-	swappgsout = vmm.v_swappgsout;
-#endif
-
 	/* user */
 	buf->user = buf->total - buf->free - buf->shared - buf->buffer;
+
+	/* Set the values to return */
+	buf->flags = _glibtop_sysdeps_mem;
 }

sysdeps/freebsd/msg_limits.c

@@ -53,14 +53,18 @@ static struct nlist nlst [] = {
 void
 glibtop_init_msg_limits_p (glibtop *server)
 {
-	server->sysdeps.msg_limits = _glibtop_sysdeps_msg_limits;
+	if (kvm_nlist (server->machine.kd, nlst) != 0) {
-
+		glibtop_warn_io_r (server, "kvm_nlist (msg_limits)");
-	if (kvm_nlist (server->machine.kd, nlst) != 0)
+		return;
-		glibtop_error_io_r (server, "kvm_nlist");
+	}
 	
 	if (kvm_read (server->machine.kd, nlst [0].n_value,
-		      &_msginfo, sizeof (_msginfo)) != sizeof (_msginfo))
+		      &_msginfo, sizeof (_msginfo)) != sizeof (_msginfo)) {
-		glibtop_error_io_r (server, "kvm_read (msginfo)");
+		glibtop_warn_io_r (server, "kvm_read (msginfo)");
+		return;
+	}
+
+	server->sysdeps.msg_limits = _glibtop_sysdeps_msg_limits;
 }
 
 /* Provides information about sysv ipc limits. */
@@ -72,6 +76,9 @@ glibtop_get_msg_limits_p (glibtop *server, glibtop_msg_limits *buf)
 	
 	memset (buf, 0, sizeof (glibtop_msg_limits));
 
+	if (server->sysdeps.msg_limits == 0)
+		return;
+
 	buf->msgmax = _msginfo.msgmax;
 	buf->msgmni = _msginfo.msgmni;
 	buf->msgmnb = _msginfo.msgmnb;

sysdeps/freebsd/open.c

@@ -57,8 +57,6 @@ glibtop_open_p (glibtop *server, const char *program_name,
 
 	/* !!! WE ARE ROOT HERE - CHANGE WITH CAUTION !!! */
 
-	server->name = program_name;
-
 	server->machine.uid = getuid ();
 	server->machine.euid = geteuid ();
 	server->machine.gid = getgid ();

sysdeps/freebsd/procargs.c

@@ -52,17 +52,23 @@ glibtop_get_proc_args_p (glibtop *server, glibtop_proc_args *buf,
 	unsigned size = 0;
 	int count;
 
+	char filename [BUFSIZ];
+	struct stat statb;
+
 	glibtop_init_p (server, (1 << GLIBTOP_SYSDEPS_PROC_ARGS), 0);
 	
 	memset (buf, 0, sizeof (glibtop_proc_args));
 
-	glibtop_suid_enter (server);
+	sprintf (filename, "/proc/%d/mem", pid);
+	if (stat (filename, &statb)) return NULL;
 
 	/* Get the process data */
 	pinfo = kvm_getprocs (server->machine.kd, KERN_PROC_PID, pid, &count);
 	if ((pinfo == NULL) || (count < 1))
 		glibtop_error_io_r (server, "kvm_getprocs (proc_args)");
 	
+	glibtop_suid_enter (server);
+
 	args = kvm_getargv (server->machine.kd, pinfo, max_len);
 	if (args == NULL) {
 		glibtop_warn_io_r (server, "kvm_getargv");

sysdeps/freebsd/prockernel.c

@@ -71,17 +71,33 @@ glibtop_get_proc_kernel_p (glibtop *server,
 	struct pcb pcb;
 	int count;
 
+	char filename [BUFSIZ];
+	struct stat statb;
+
 	glibtop_init_p (server, (1 << GLIBTOP_SYSDEPS_PROC_KERNEL), 0);
 	
 	memset (buf, 0, sizeof (glibtop_proc_kernel));
 
-	glibtop_suid_enter (server);
+	if (server->sysdeps.proc_time == 0)
+		return;
 
 	/* Get the process information */
 	pinfo = kvm_getprocs (server->machine.kd, KERN_PROC_PID, pid, &count);
 	if ((pinfo == NULL) || (count != 1))
 		glibtop_error_io_r (server, "kvm_getprocs (%d)", pid);
 
+	buf->nwchan = (unsigned long) pinfo [0].kp_proc.p_wchan &~ KERNBASE;
+	buf->flags |= (1 << GLIBTOP_PROC_KERNEL_NWCHAN);
+
+	if (pinfo [0].kp_proc.p_wchan && pinfo [0].kp_proc.p_wmesg) {
+		strncpy (buf->wchan, pinfo [0].kp_eproc.e_wmesg,
+			 sizeof (buf->wchan) - 1);
+		buf->wchan [sizeof (buf->wchan) - 1] = 0;
+		buf->flags |= (1 << GLIBTOP_PROC_KERNEL_WCHAN);
+	} else {
+		buf->wchan [0] = 0;
+	}
+
 	/* Taken from `saveuser ()' in `/usr/src/bin/ps/ps.c'. */
 
 	/* [FIXME]: /usr/include/sys/user.h tells me that the user area
@@ -93,6 +109,11 @@ glibtop_get_proc_kernel_p (glibtop *server,
 	/* NOTE: You need to mount the /proc filesystem to make
 	 *       `kvm_uread' work. */
 
+	sprintf (filename, "/proc/%d/mem", pid);
+	if (stat (filename, &statb)) return;
+
+	glibtop_suid_enter (server);
+
 	if ((pinfo [0].kp_proc.p_flag & P_INMEM) &&
 	    kvm_uread (server->machine.kd, &(pinfo [0]).kp_proc,
 		       (unsigned long) &u_addr->u_stats,
@@ -129,16 +150,4 @@ glibtop_get_proc_kernel_p (glibtop *server,
 	/* Taken from `wchan ()' in `/usr/src/bin/ps/print.c'. */
 
 	glibtop_suid_leave (server);
-
-	buf->nwchan = (unsigned long) pinfo [0].kp_proc.p_wchan &~ KERNBASE;
-
-	if (pinfo [0].kp_proc.p_wchan && pinfo [0].kp_proc.p_wmesg) {
-		strncpy (buf->wchan, pinfo [0].kp_eproc.e_wmesg,
-			 sizeof (buf->wchan) - 1);
-		buf->wchan [sizeof (buf->wchan) - 1] = 0;
-	} else {
-		buf->wchan [0] = 0;
-	}
-	
-	buf->flags |= _glibtop_sysdeps_proc_kernel_wchan;
 }

sysdeps/freebsd/proclist.c

@@ -69,17 +69,14 @@ glibtop_get_proclist_p (glibtop *server, glibtop_proclist *buf,
 	
 	memset (buf, 0, sizeof (glibtop_proclist));
 
-	glibtop_suid_enter (server);
-
 	which = (int)(real_which & GLIBTOP_KERN_PROC_MASK);
 
 	/* Get the process data */
 	pinfo = kvm_getprocs (server->machine.kd, which, arg, &count);
-	if ((pinfo == NULL) || (count < 1))
+	if ((pinfo == NULL) || (count < 1)) {
-		glibtop_error_io_r (server, "kvm_getprocs (proclist)");
+		glibtop_warn_io_r (server, "kvm_getprocs (proclist)");
-
+		return NULL;
-	glibtop_suid_leave (server);
+	}
-
 	count--;
 
 	/* Allocate count objects in the pids_chain array

sysdeps/freebsd/procmem.c

@@ -66,8 +66,6 @@ glibtop_init_proc_mem_p (glibtop *server)
 {
 	register int pagesize;
 
-	server->sysdeps.proc_mem = _glibtop_sysdeps_proc_mem;
-
 	/* get the page size with "getpagesize" and calculate pageshift
 	 * from it */
 	pagesize = getpagesize ();
@@ -79,6 +77,8 @@ glibtop_init_proc_mem_p (glibtop *server)
 
 	/* we only need the amount of log(2)1024 for our conversion */
 	pageshift -= LOG1024;
+
+	server->sysdeps.proc_mem = _glibtop_sysdeps_proc_mem;
 }
 
 /* Provides detailed information about a process. */
@@ -98,17 +98,22 @@ glibtop_get_proc_mem_p (glibtop *server, glibtop_proc_mem *buf,
 	
 	memset (buf, 0, sizeof (glibtop_proc_mem));
 
-	glibtop_suid_enter (server);
+	if (server->sysdeps.proc_mem == 0)
+		return;
 
 	/* Get the process data */
 	pinfo = kvm_getprocs (server->machine.kd, KERN_PROC_PID, pid, &count);
-	if ((pinfo == NULL) || (count < 1))
+	if ((pinfo == NULL) || (count < 1)) {
-		glibtop_error_io_r (server, "kvm_getprocs (proclist)");
+		glibtop_warn_io_r (server, "kvm_getprocs (proclist)");
+		return;
+	}
 
 	if (kvm_read (server->machine.kd,
 		      (unsigned long) pinfo [0].kp_proc.p_limit,
-		      (char *) &plimit, sizeof (plimit)) != sizeof (plimit))
+		      (char *) &plimit, sizeof (plimit)) != sizeof (plimit)) {
-		glibtop_error_io_r (server, "kvm_read (plimit)");
+		glibtop_warn_io_r (server, "kvm_read (plimit)");
+		return;
+	}
 
 	buf->rss_rlim = (u_int64_t) 
 		(plimit.pl_rlimit [RLIMIT_RSS].rlim_cur);
@@ -125,15 +130,19 @@ glibtop_get_proc_mem_p (glibtop *server, glibtop_proc_mem *buf,
 
 	if (kvm_read (server->machine.kd,
 		      (unsigned long) pinfo [0].kp_proc.p_vmspace,
-		      (char *) &vmspace, sizeof (vmspace)) != sizeof (vmspace))
+		      (char *) &vmspace, sizeof (vmspace)) != sizeof (vmspace)) {
-		glibtop_error_io_r (server, "kvm_read (vmspace)");
+		glibtop_warn_io_r (server, "kvm_read (vmspace)");
+		return;
+	}
 
 	first = vmspace.vm_map.header.next;
 
 	if (kvm_read (server->machine.kd,
 		      (unsigned long) vmspace.vm_map.header.next,
-		      (char *) &entry, sizeof (entry)) != sizeof (entry))
+		      (char *) &entry, sizeof (entry)) != sizeof (entry)) {
-		glibtop_error_io_r (server, "kvm_read (entry)");
+		glibtop_warn_io_r (server, "kvm_read (entry)");
+		return;
+	}
 
 	/* Walk through the `vm_map_entry' list ... */
 
@@ -144,8 +153,10 @@ glibtop_get_proc_mem_p (glibtop *server, glibtop_proc_mem *buf,
 	while (entry.next != first) {
 		if (kvm_read (server->machine.kd,
 			      (unsigned long) entry.next,
-			      &entry, sizeof (entry)) != sizeof (entry))
+			      &entry, sizeof (entry)) != sizeof (entry)) {
-			glibtop_error_io_r (server, "kvm_read (entry)");
+			glibtop_warn_io_r (server, "kvm_read (entry)");
+			return;
+		}
 
 		if (entry.eflags & (MAP_ENTRY_IS_A_MAP|MAP_ENTRY_IS_SUB_MAP))
 			continue;
@@ -157,8 +168,10 @@ glibtop_get_proc_mem_p (glibtop *server, glibtop_proc_mem *buf,
 
 		if (kvm_read (server->machine.kd,
 			      (unsigned long) entry.object.vm_object,
-			      &object, sizeof (object)) != sizeof (object))
+			      &object, sizeof (object)) != sizeof (object)) {
-			glibtop_error_io_r (server, "kvm_read (object)");
+			glibtop_warn_io_r (server, "kvm_read (object)");
+			return;
+		}
 
 		/* If the object is of type vnode, add its size */
 
@@ -168,7 +181,5 @@ glibtop_get_proc_mem_p (glibtop *server, glibtop_proc_mem *buf,
 		buf->share += object.un_pager.vnp.vnp_size;
 	}
 
-	glibtop_suid_leave (server);
-
 	buf->flags = _glibtop_sysdeps_proc_mem;
 }

sysdeps/freebsd/procsignal.c

@@ -51,14 +51,12 @@ glibtop_get_proc_signal_p (glibtop *server,
 	
 	memset (buf, 0, sizeof (glibtop_proc_signal));
 
-	glibtop_suid_enter (server);
-
 	/* Get the process information */
 	pinfo = kvm_getprocs (server->machine.kd, KERN_PROC_PID, pid, &count);
-	if ((pinfo == NULL) || (count != 1))
+	if ((pinfo == NULL) || (count != 1)) {
-		glibtop_error_io_r (server, "kvm_getprocs (%d)", pid);
+		glibtop_warn_io_r (server, "kvm_getprocs (%d)", pid);
-
+		return;
-	glibtop_suid_leave (server);
+	}
 
 	/* signal: mask of pending signals.
 	 *         pinfo [0].kp_proc.p_siglist

sysdeps/freebsd/procstate.c

@@ -53,14 +53,12 @@ glibtop_get_proc_state_p (glibtop *server,
 	
 	memset (buf, 0, sizeof (glibtop_proc_state));
 
-	glibtop_suid_enter (server);
-
 	/* Get the process information */
 	pinfo = kvm_getprocs (server->machine.kd, KERN_PROC_PID, pid, &count);
-	if ((pinfo == NULL) || (count != 1))
+	if ((pinfo == NULL) || (count != 1)) {
-		glibtop_error_io_r (server, "kvm_getprocs (%d)", pid);
+		glibtop_warn_io_r (server, "kvm_getprocs (%d)", pid);
-
+		return;
-	glibtop_suid_leave (server);
+	}
 
 	strncpy (buf->cmd, pinfo [0].kp_proc.p_comm, sizeof (buf->cmd)-1);
 	buf->cmd [sizeof (buf->cmd)-1] = 0;

sysdeps/freebsd/proctime.c

@@ -77,7 +77,8 @@ calcru(p, up, sp, ip)
 	totusec = (quad_t)sec * 1000000 + usec;
 	if (totusec < 0) {
 		/* XXX no %qd in kernel.  Truncate. */
-		printf("calcru: negative time: %ld usec\n", (long)totusec);
+		fprintf (stderr, "calcru: negative time: %ld usec\n",
+			 (long)totusec);
 		totusec = 0;
 	}
 
@@ -106,17 +107,26 @@ glibtop_get_proc_time_p (glibtop *server, glibtop_proc_time *buf,
 	struct pstats pstats;
 	int count;
 
+	char filename [BUFSIZ];
+	struct stat statb;
+
 	glibtop_init_p (server, (1 << GLIBTOP_SYSDEPS_PROC_TIME), 0);
 	
 	memset (buf, 0, sizeof (glibtop_proc_time));
 
-	glibtop_suid_enter (server);
+	if (server->sysdeps.proc_time == 0)
+		return;
+
+	sprintf (filename, "/proc/%d/mem", pid);
+	if (stat (filename, &statb)) return;
 
 	/* Get the process information */
 	pinfo = kvm_getprocs (server->machine.kd, KERN_PROC_PID, pid, &count);
 	if ((pinfo == NULL) || (count != 1))
 		glibtop_error_io_r (server, "kvm_getprocs (%d)", pid);
 
+	glibtop_suid_enter (server);
+
 	if ((pinfo [0].kp_proc.p_flag & P_INMEM) &&
 	    kvm_uread (server->machine.kd, &(pinfo [0]).kp_proc,
 		       (unsigned long) &u_addr->u_stats,

sysdeps/freebsd/procuid.c

@@ -53,14 +53,12 @@ glibtop_get_proc_uid_p (glibtop *server, glibtop_proc_uid *buf,
 	
 	memset (buf, 0, sizeof (glibtop_proc_uid));
 
-	glibtop_suid_enter (server);
-
 	/* Get the process information */
 	pinfo = kvm_getprocs (server->machine.kd, KERN_PROC_PID, pid, &count);
-	if ((pinfo == NULL) || (count != 1))
+	if ((pinfo == NULL) || (count != 1)) {
-		glibtop_error_io_r (server, "kvm_getprocs (%d)", pid);
+		glibtop_warn_io_r (server, "kvm_getprocs (%d)", pid);
-
+		return;
-	glibtop_suid_leave (server);
+	}
 
 	buf->uid  = pinfo [0].kp_eproc.e_pcred.p_ruid;
 	buf->euid = pinfo [0].kp_eproc.e_pcred.p_svuid;

sysdeps/freebsd/sem_limits.c

@@ -55,14 +55,18 @@ static struct nlist nlst [] = {
 void
 glibtop_init_sem_limits_p (glibtop *server)
 {
-	server->sysdeps.sem_limits = _glibtop_sysdeps_sem_limits;
+	if (kvm_nlist (server->machine.kd, nlst) != 0) {
-
+		glibtop_warn_io_r (server, "kvm_nlist (sem_limits)");
-	if (kvm_nlist (server->machine.kd, nlst) != 0)
+		return;
-		glibtop_error_io_r (server, "kvm_nlist");
+	}
 	
 	if (kvm_read (server->machine.kd, nlst [0].n_value,
-		      &_seminfo, sizeof (_seminfo)) != sizeof (_seminfo))
+		      &_seminfo, sizeof (_seminfo)) != sizeof (_seminfo)) {
-		glibtop_error_io_r (server, "kvm_read (seminfo)");
+		glibtop_warn_io_r (server, "kvm_read (seminfo)");
+		return;
+	}
+
+	server->sysdeps.sem_limits = _glibtop_sysdeps_sem_limits;
 }
 
 /* Provides information about sysv sem limits. */
@@ -74,6 +78,9 @@ glibtop_get_sem_limits_p (glibtop *server, glibtop_sem_limits *buf)
 	
 	memset (buf, 0, sizeof (glibtop_sem_limits));
 	
+	if (server->sysdeps.sem_limits == 0)
+		return;
+
 	buf->semmap = _seminfo.semmap;
 	buf->semmni = _seminfo.semmni;
 	buf->semmns = _seminfo.semmns;

sysdeps/freebsd/shm_limits.c

@@ -53,14 +53,18 @@ static struct nlist nlst [] = {
 void
 glibtop_init_shm_limits_p (glibtop *server)
 {
-	server->sysdeps.shm_limits = _glibtop_sysdeps_shm_limits;
+	if (kvm_nlist (server->machine.kd, nlst) != 0) {
-
+		glibtop_warn_io_r (server, "kvm_nlist (shm_limits)");
-	if (kvm_nlist (server->machine.kd, nlst) != 0)
+		return;
-		glibtop_error_io_r (server, "kvm_nlist");
+	}
 	
 	if (kvm_read (server->machine.kd, nlst [0].n_value,
-		      &_shminfo, sizeof (_shminfo)) != sizeof (_shminfo))
+		      &_shminfo, sizeof (_shminfo)) != sizeof (_shminfo)) {
-		glibtop_error_io_r (server, "kvm_read (shminfo)");
+		glibtop_warn_io_r (server, "kvm_read (shminfo)");
+		return;
+	}
+
+	server->sysdeps.shm_limits = _glibtop_sysdeps_shm_limits;
 }
 
 /* Provides information about sysv ipc limits. */
@@ -72,6 +76,9 @@ glibtop_get_shm_limits_p (glibtop *server, glibtop_shm_limits *buf)
 	
 	memset (buf, 0, sizeof (glibtop_shm_limits));
 
+	if (server->sysdeps.shm_limits == 0)
+		return;
+
 	buf->shmmax = _shminfo.shmmax;
 	buf->shmmin = _shminfo.shmmin;
 	buf->shmmni = _shminfo.shmmni;

sysdeps/freebsd/swap.c

@@ -56,10 +56,12 @@ static struct nlist nlst [] = {
 void
 glibtop_init_swap_p (glibtop *server)
 {
-	server->sysdeps.swap = _glibtop_sysdeps_swap;
+	if (kvm_nlist (server->machine.kd, nlst) != 0) {
+		glibtop_warn_io_r (server, "kvm_nlist (swap)");
+		return;
+	}
 
-	if (kvm_nlist (server->machine.kd, nlst) != 0)
+	server->sysdeps.swap = _glibtop_sysdeps_swap;
-		glibtop_error_io_r (server, "kvm_nlist");
 }
 
 /* Provides information about swap usage. */
@@ -92,11 +94,16 @@ glibtop_get_swap_p (glibtop *server, glibtop_swap *buf)
 	
 	memset (buf, 0, sizeof (glibtop_swap));
 
+	if (server->sysdeps.swap == 0)
+		return;
+
 	/* This is used to get the `pagein' and `pageout' members. */
 	
 	if (kvm_read (server->machine.kd, nlst[0].n_value,
-		      &vmm, sizeof (vmm)) != sizeof (vmm))
+		      &vmm, sizeof (vmm)) != sizeof (vmm)) {
-		glibtop_error_io_r (server, "kvm_read (cnt)");
+		glibtop_warn_io_r (server, "kvm_read (cnt)");
+		return;
+	}
 	
         if (swappgsin < 0) {
 		buf->pagein = 0;
@@ -112,40 +119,52 @@ glibtop_get_swap_p (glibtop *server, glibtop_swap *buf)
 	/* Size of largest swap device. */
 
 	if (kvm_read (server->machine.kd, nlst[VM_NSWAP].n_value,
-		      &nswap, sizeof (nswap)) != sizeof (nswap))
+		      &nswap, sizeof (nswap)) != sizeof (nswap)) {
-		glibtop_error_io_r (server, "kvm_read (nswap)");
+		glibtop_warn_io_r (server, "kvm_read (nswap)");
+		return;
+	}
 
 	/* Number of swap devices. */
 
 	if (kvm_read (server->machine.kd, nlst[VM_NSWDEV].n_value,
-		      &nswdev, sizeof (nswdev)) != sizeof (nswdev))
+		      &nswdev, sizeof (nswdev)) != sizeof (nswdev)) {
-		glibtop_error_io_r (server, "kvm_read (nswdev)");
+		glibtop_warn_io_r (server, "kvm_read (nswdev)");
+		return;
+	}
 
 	/* Maximum size of a swap block. */
 
 	if (kvm_read (server->machine.kd, nlst[VM_DMMAX].n_value,
-		      &dmmax, sizeof (dmmax)) != sizeof (dmmax))
+		      &dmmax, sizeof (dmmax)) != sizeof (dmmax)) {
-		glibtop_error_io_r (server, "kvm_read (dmmax)");
+		glibtop_warn_io_r (server, "kvm_read (dmmax)");
+		return;
+	}
 
 	/* List of free swap areas. */
 
 	if (kvm_read (server->machine.kd, nlst[VM_SWAPLIST].n_value,
-		      &swaplist, sizeof (swaplist)) != sizeof (swaplist))
+		      &swaplist, sizeof (swaplist)) != sizeof (swaplist)) {
-		glibtop_error_io_r (server, "kvm_read (swaplist)");
+		glibtop_warn_io_r (server, "kvm_read (swaplist)");
+		return;
+	}
 
 	/* Kernel offset of list of swap devices and sizes. */
 
 	if (kvm_read (server->machine.kd, nlst[VM_SWDEVT].n_value,
-		      &ptr, sizeof (ptr)) != sizeof (ptr))
+		      &ptr, sizeof (ptr)) != sizeof (ptr)) {
-		glibtop_error_io_r (server, "kvm_read (swaplist)");
+		glibtop_warn_io_r (server, "kvm_read (swaplist)");
+		return;
+	}
 
 	/* List of swap devices and sizes. */
 
 	sw_size = nswdev * sizeof (*sw);
 	sw = glibtop_malloc_r (server, sw_size);
 
-	if (kvm_read (server->machine.kd, ptr, sw, sw_size) != (ssize_t) sw_size)
+	if (kvm_read (server->machine.kd, ptr, sw, sw_size) != (ssize_t)sw_size) {
-		glibtop_error_io_r (server, "kvm_read (*swdevt)");
+		glibtop_warn_io_r (server, "kvm_read (*swdevt)");
+		return;
+	}
 
 	perdev = glibtop_malloc (nswdev * sizeof (*perdev));
 
@@ -160,8 +179,10 @@ glibtop_get_swap_p (glibtop *server, glibtop_swap *buf)
 		int	top, bottom, next_block;
 
 		if (kvm_read (server->machine.kd, (int) swapptr, &head,
-			      sizeof (struct rlist)) != sizeof (struct rlist))
+			      sizeof (struct rlist)) != sizeof (struct rlist)) {
-			glibtop_error_io_r (server, "kvm_read (swapptr)");
+			glibtop_warn_io_r (server, "kvm_read (swapptr)");
+			return;
+		}
 
 		top = head.rl_end;
 		bottom = head.rl_start;