oxmc/libgtop
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Use glibtop_warn_io_r () instead of glibtop_error_io_r ().

Browse Source 
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.
This commit is contained in:
Martin Baulig
1998-10-30 23:06:56 +00:00
committed by Martin Baulig
parent 0fec2b7fb0
commit 82fdca61c2
16 changed files with 219 additions and 134 deletions
Download Patch File Download Diff File Expand all files Collapse all files

7
sysdeps/freebsd/ChangeLog
View File

@@ -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.

30
sysdeps/freebsd/cpu.c
View File

@@ -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)
glibtop_error_io_r (server, "kvm_nlist");
/* Set this only if kvm_nlist () succeeded. */
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))
glibtop_error_io_r (server, "kvm_read (cp_time)");
&cpts, sizeof (cpts)) != sizeof (cpts)) {
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))
glibtop_error_io_r (server, "sysctl");
buf->flags = _glibtop_sysdeps_cpu;
if (sysctl (mib, mib_length, &ci, &length, NULL, 0)) {
glibtop_warn_io_r (server, "sysctl");
return;
}
/* 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;
}

49
sysdeps/freebsd/mem.c
View File

@@ -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_error_io_r (server, "kvm_nlist");
if (kvm_nlist (server->machine.kd, nlst) != 0) {
glibtop_warn_io_r (server, "kvm_nlist (mem)");
return;
}
/* 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))
glibtop_error_io_r (server, "sysctl");
if (sysctl (mib, 2, &vmt, &length_vmt, NULL, 0)) {
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))
glibtop_error_io_r (server, "kvm_read (cnt)");
&vmm, sizeof (vmm)) != sizeof (vmm)) {
glibtop_warn_io_r (server, "kvm_read (cnt)");
return;
}
if (kvm_read (server->machine.kd, nlst[1].n_value,
&bufspace, sizeof (bufspace)) != sizeof (bufspace))
glibtop_error_io_r (server, "kvm_read (bufspace)");
/* Set the values to return */
buf->flags = _glibtop_sysdeps_mem;
&bufspace, sizeof (bufspace)) != sizeof (bufspace)) {
glibtop_warn_io_r (server, "kvm_read (bufspace)");
return;
}
/* 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;
}

19
sysdeps/freebsd/msg_limits.c
View File

@@ -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_error_io_r (server, "kvm_nlist");
if (kvm_nlist (server->machine.kd, nlst) != 0) {
glibtop_warn_io_r (server, "kvm_nlist (msg_limits)");
return;
}
if (kvm_read (server->machine.kd, nlst [0].n_value,
&_msginfo, sizeof (_msginfo)) != sizeof (_msginfo))
glibtop_error_io_r (server, "kvm_read (msginfo)");
&_msginfo, sizeof (_msginfo)) != sizeof (_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;

2
sysdeps/freebsd/open.c
View File

@@ -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 ();

8
sysdeps/freebsd/procargs.c
View File

@@ -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");

35
sysdeps/freebsd/prockernel.c
View File

@@ -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;
}

11
sysdeps/freebsd/proclist.c
View File

@@ -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))
glibtop_error_io_r (server, "kvm_getprocs (proclist)");
glibtop_suid_leave (server);
if ((pinfo == NULL) || (count < 1)) {
glibtop_warn_io_r (server, "kvm_getprocs (proclist)");
return NULL;
}
count--;
/* Allocate count objects in the pids_chain array

45
sysdeps/freebsd/procmem.c
View File

@@ -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))
glibtop_error_io_r (server, "kvm_getprocs (proclist)");
if ((pinfo == NULL) || (count < 1)) {
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))
glibtop_error_io_r (server, "kvm_read (plimit)");
(char *) &plimit, sizeof (plimit)) != sizeof (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))
glibtop_error_io_r (server, "kvm_read (vmspace)");
(char *) &vmspace, sizeof (vmspace)) != sizeof (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))
glibtop_error_io_r (server, "kvm_read (entry)");
(char *) &entry, sizeof (entry)) != sizeof (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))
glibtop_error_io_r (server, "kvm_read (entry)");
&entry, sizeof (entry)) != sizeof (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))
glibtop_error_io_r (server, "kvm_read (object)");
&object, sizeof (object)) != sizeof (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;
}

10
sysdeps/freebsd/procsignal.c
View File

@@ -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))
glibtop_error_io_r (server, "kvm_getprocs (%d)", pid);
glibtop_suid_leave (server);
if ((pinfo == NULL) || (count != 1)) {
glibtop_warn_io_r (server, "kvm_getprocs (%d)", pid);
return;
}
/* signal: mask of pending signals.
* pinfo [0].kp_proc.p_siglist

10
sysdeps/freebsd/procstate.c
View File

@@ -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))
glibtop_error_io_r (server, "kvm_getprocs (%d)", pid);
glibtop_suid_leave (server);
if ((pinfo == NULL) || (count != 1)) {
glibtop_warn_io_r (server, "kvm_getprocs (%d)", pid);
return;
}
strncpy (buf->cmd, pinfo [0].kp_proc.p_comm, sizeof (buf->cmd)-1);
buf->cmd [sizeof (buf->cmd)-1] = 0;

14
sysdeps/freebsd/proctime.c
View File

@@ -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,

10
sysdeps/freebsd/procuid.c
View File

@@ -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))
glibtop_error_io_r (server, "kvm_getprocs (%d)", pid);
glibtop_suid_leave (server);
if ((pinfo == NULL) || (count != 1)) {
glibtop_warn_io_r (server, "kvm_getprocs (%d)", pid);
return;
}
buf->uid = pinfo [0].kp_eproc.e_pcred.p_ruid;
buf->euid = pinfo [0].kp_eproc.e_pcred.p_svuid;

19
sysdeps/freebsd/sem_limits.c
View File

@@ -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_error_io_r (server, "kvm_nlist");
if (kvm_nlist (server->machine.kd, nlst) != 0) {
glibtop_warn_io_r (server, "kvm_nlist (sem_limits)");
return;
}
if (kvm_read (server->machine.kd, nlst [0].n_value,
&_seminfo, sizeof (_seminfo)) != sizeof (_seminfo))
glibtop_error_io_r (server, "kvm_read (seminfo)");
&_seminfo, sizeof (_seminfo)) != sizeof (_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;

19
sysdeps/freebsd/shm_limits.c
View File

@@ -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_error_io_r (server, "kvm_nlist");
if (kvm_nlist (server->machine.kd, nlst) != 0) {
glibtop_warn_io_r (server, "kvm_nlist (shm_limits)");
return;
}
if (kvm_read (server->machine.kd, nlst [0].n_value,
&_shminfo, sizeof (_shminfo)) != sizeof (_shminfo))
glibtop_error_io_r (server, "kvm_read (shminfo)");
&_shminfo, sizeof (_shminfo)) != sizeof (_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;

59
sysdeps/freebsd/swap.c
View File

@@ -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)
glibtop_error_io_r (server, "kvm_nlist");
server->sysdeps.swap = _glibtop_sysdeps_swap;
}
/* 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))
glibtop_error_io_r (server, "kvm_read (cnt)");
&vmm, sizeof (vmm)) != sizeof (vmm)) {
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))
glibtop_error_io_r (server, "kvm_read (nswap)");
&nswap, sizeof (nswap)) != sizeof (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))
glibtop_error_io_r (server, "kvm_read (nswdev)");
&nswdev, sizeof (nswdev)) != sizeof (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))
glibtop_error_io_r (server, "kvm_read (dmmax)");
&dmmax, sizeof (dmmax)) != sizeof (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))
glibtop_error_io_r (server, "kvm_read (swaplist)");
&swaplist, sizeof (swaplist)) != sizeof (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))
glibtop_error_io_r (server, "kvm_read (swaplist)");
&ptr, sizeof (ptr)) != sizeof (ptr)) {
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)
glibtop_error_io_r (server, "kvm_read (*swdevt)");
if (kvm_read (server->machine.kd, ptr, sw, sw_size) != (ssize_t)sw_size) {
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))
glibtop_error_io_r (server, "kvm_read (swapptr)");
sizeof (struct rlist)) != sizeof (struct rlist)) {
glibtop_warn_io_r (server, "kvm_read (swapptr)");
return;
}
top = head.rl_end;
bottom = head.rl_start;