Chillcraft/libgtop
3
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Reflect latest interface changes.

Browse Source
This commit is contained in:
Martin Baulig
1999-12-25 19:50:36 +00:00
parent e7b42a66b1
commit c76bf0bfab
10 changed files with 355 additions and 303 deletions
Download Patch File Download Diff File Expand all files Collapse all files

80
sysdeps/solaris/procargs.c
View File

@@ -26,58 +26,70 @@
#include <glibtop/xmalloc.h>
#include <glibtop/procargs.h>
#include <glibtop_private.h>
static const unsigned long _glibtop_sysdeps_proc_args =
(1L << GLIBTOP_PROC_ARGS_SIZE);
(1L << GLIBTOP_ARRAY_SIZE) + (1L << GLIBTOP_ARRAY_NUMBER);
/* Init function. */
int
glibtop_init_proc_args_s (glibtop *server)
{
server->sysdeps.proc_args = _glibtop_sysdeps_proc_args;
server->sysdeps.proc_args = _glibtop_sysdeps_proc_args;
return 0;
}
/* Provides detailed information about a process. */
char *
glibtop_get_proc_args_s (glibtop *server, glibtop_proc_args *buf,
pid_t pid, unsigned max_len)
char **
glibtop_get_proc_args_s (glibtop *server, glibtop_array *array, pid_t pid)
{
#ifdef HAVE_PROCFS_H
struct psinfo pinfo;
struct psinfo pinfo;
#else
struct prpsinfo pinfo;
struct prpsinfo pinfo;
#endif
int len, i;
char *ret, *p;
int retval, len, i, count;
char *ret, *p, **ptrlist;
memset (buf, 0, sizeof (glibtop_proc_args));
memset (array, 0, sizeof (glibtop_array));
if(glibtop_get_proc_data_psinfo_s(server, &pinfo, pid))
return NULL;
retval = glibtop_get_proc_data_psinfo_s(server, &pinfo, pid);
if (retval) {
server->glibtop_errno = retval;
return NULL;
}
for(len = 0; len < PRARGSZ; ++len)
if(!(pinfo.pr_psargs[len]))
break;
if(max_len)
{
ret = glibtop_malloc_r(server, max_len + 1);
if(max_len < len)
len = max_len;
memcpy(ret, pinfo.pr_psargs, len);
ret[len] = 0;
for(len = 0; len < PRARGSZ; ++len)
if(!(pinfo.pr_psargs[len]))
break;
ret = glibtop_malloc_r (server, len+1);
memcpy(ret, pinfo.pr_psargs, len);
ret[len] = 0;
count = 0;
for(p = ret; *p; ++p)
if(*p == ' ') {
*p = 0; count++;
}
else
{
ret = glibtop_malloc_r(server, len + 1);
memcpy(ret, pinfo.pr_psargs, len);
ret[len] = 0;
buf->size = len;
buf->flags = _glibtop_sysdeps_proc_args;
}
for(p = ret; *p; ++p)
if(*p == ' ')
*p = 0;
return ret;
ptrlist = glibtop_calloc_r(server, len+1, sizeof (char *));
for (i = 0, p = ret; i < count; i++) {
ptrlist [i] = glibtop_strdup_r (server, p);
p += strlen (p) + 1;
}
ptrlist [count] = NULL;
glibtop_free_r (server, ret);
array->number = count;
array->size = sizeof (char *);
array->flags = _glibtop_sysdeps_proc_args;
return ptrlist;
}

8
sysdeps/solaris/prockernel.c
View File

@@ -31,7 +31,9 @@ static const unsigned long _glibtop_sysdeps_proc_kernel = 0;
int
glibtop_init_proc_kernel_s (glibtop *server)
{
server->sysdeps.proc_kernel = _glibtop_sysdeps_proc_kernel;
server->sysdeps.proc_kernel = _glibtop_sysdeps_proc_kernel;
return 0;
}
/* Provides detailed information about a process. */
@@ -40,5 +42,7 @@ int
glibtop_get_proc_kernel_s (glibtop *server, glibtop_proc_kernel *buf,
pid_t pid)
{
memset (buf, 0, sizeof (glibtop_proc_kernel));
memset (buf, 0, sizeof (glibtop_proc_kernel));
return 0;
}

34
sysdeps/solaris/proclist.c
View File

@@ -30,11 +30,11 @@
#include <dirent.h>
#include <ctype.h>
#define GLIBTOP_PROCLIST_FLAGS 3
#include <glibtop_private.h>
static const unsigned long _glibtop_sysdeps_proclist =
(1L << GLIBTOP_PROCLIST_TOTAL) + (1L << GLIBTOP_PROCLIST_NUMBER) +
(1L << GLIBTOP_PROCLIST_SIZE);
(1L << GLIBTOP_ARRAY_TOTAL) + (1L << GLIBTOP_ARRAY_NUMBER) +
(1L << GLIBTOP_ARRAY_SIZE);
/* Init function. */
@@ -42,6 +42,8 @@ int
glibtop_init_proclist_s (glibtop *server)
{
server->sysdeps.proclist = _glibtop_sysdeps_proclist;
return 0;
}
#define BLOCK_COUNT 256
@@ -55,7 +57,7 @@ glibtop_init_proclist_s (glibtop *server)
* each buf->size big. The total size is stored in buf->total. */
unsigned *
glibtop_get_proclist_s (glibtop *server, glibtop_proclist *buf,
glibtop_get_proclist_s (glibtop *server, glibtop_array *array,
int64_t which, int64_t arg)
{
DIR *proc;
@@ -65,15 +67,17 @@ glibtop_get_proclist_s (glibtop *server, glibtop_proclist *buf,
unsigned pids [BLOCK_COUNT], *pids_chain = NULL;
unsigned pids_size = 0, pids_offset = 0, new_size;
struct stat statb;
int len, i, ok;
int len, ok;
memset (buf, 0, sizeof (glibtop_proclist));
memset (array, 0, sizeof (glibtop_array));
mask = which & ~GLIBTOP_KERN_PROC_MASK;
which &= GLIBTOP_KERN_PROC_MASK;
/* Check if the user wanted only one process */
if(which == GLIBTOP_KERN_PROC_PID) {
pid = arg;
if(mask) {
#ifdef HAVE_PROCFS_H
struct psinfo psinfo;
@@ -89,13 +93,17 @@ glibtop_get_proclist_s (glibtop *server, glibtop_proclist *buf,
if(mask & GLIBTOP_EXCLUDE_NOTTY && psinfo.pr_ttydev == PRNODEV)
return NULL;
} else {
sprintf(buffer, "/proc/%d", arg);
sprintf(buffer, "/proc/%ld", (long)arg);
if(s_stat(buffer, &statb) < 0)
return NULL;
}
if(!(pids_chain = glibtop_malloc(sizeof(unsigned))))
if(!(pids_chain = glibtop_calloc_r(server, 1, sizeof(unsigned))))
return NULL;
*pids_chain = pid;
array->number = 1;
array->size = sizeof(unsigned);
array->total = array->number * array->size;
array->flags = _glibtop_sysdeps_proclist;
return pids_chain;
}
@@ -235,15 +243,15 @@ glibtop_get_proclist_s (glibtop *server, glibtop_proclist *buf,
pids_offset += BLOCK_COUNT;
/* Since everything is ok now, we can set buf->flags, fill in the
/* Since everything is ok now, we can set array->flags, fill in the
* remaining fields and return the `pids_chain'. */
buf->flags = _glibtop_sysdeps_proclist;
array->flags = _glibtop_sysdeps_proclist;
buf->size = sizeof (unsigned);
buf->number = total;
array->size = sizeof (unsigned);
array->number = total;
buf->total = total * sizeof (unsigned);
array->total = array->number * array->size;
return pids_chain;
}

264
sysdeps/solaris/procmap.c
View File

@@ -30,41 +30,42 @@
#include <errno.h>
#include <alloca.h>
#include "safeio.h"
#include <glibtop_private.h>
static const unsigned long _glibtop_sysdeps_proc_map =
(1L << GLIBTOP_PROC_MAP_NUMBER) + (1L << GLIBTOP_PROC_MAP_TOTAL) +
(1L << GLIBTOP_PROC_MAP_SIZE);
(1L << GLIBTOP_ARRAY_NUMBER) + (1L << GLIBTOP_ARRAY_TOTAL) +
(1L << GLIBTOP_ARRAY_SIZE);
static const unsigned long _glibtop_sysdeps_map_entry =
(1L << GLIBTOP_MAP_ENTRY_START) + (1L << GLIBTOP_MAP_ENTRY_END) +
(1L << GLIBTOP_MAP_ENTRY_OFFSET) + (1L << GLIBTOP_MAP_ENTRY_PERM);
static const unsigned long _glibtop_sysdeps_map_device =
(1L << GLIBTOP_MAP_ENTRY_DEVICE) + (1L << GLIBTOP_MAP_ENTRY_INODE);
/* Init function. */
int
glibtop_init_proc_map_s (glibtop *server)
{
server->sysdeps.proc_map = _glibtop_sysdeps_proc_map;
server->sysdeps.proc_map = _glibtop_sysdeps_proc_map;
return 0;
}
/* Provides detailed information about a process. */
glibtop_map_entry *
glibtop_get_proc_map_s (glibtop *server, glibtop_proc_map *buf, pid_t pid)
glibtop_get_proc_map_s (glibtop *server, glibtop_array *array, pid_t pid)
{
int fd, i, nmaps, pr_err, heap;
int fd, i, nmaps, pr_err, heap;
#if GLIBTOP_SOLARIS_RELEASE >= 560
prxmap_t *maps;
struct ps_prochandle *Pr;
prxmap_t *maps;
struct ps_prochandle *Pr = NULL;
#else
prmap_t *maps;
prmap_t *maps;
#endif
/* A few defines, to make it shorter down there */
/* A few defines, to make it shorter down there */
#ifdef HAVE_PROCFS_H
# define OFFSET pr_offset
@@ -72,136 +73,125 @@ glibtop_get_proc_map_s (glibtop *server, glibtop_proc_map *buf, pid_t pid)
# define OFFSET pr_off
#endif
glibtop_map_entry *entry;
struct stat inode;
char buffer[BUFSIZ];
glibtop_map_entry *entry;
struct stat inode;
char buffer[BUFSIZ];
memset (buf, 0, sizeof (glibtop_proc_map));
memset (array, 0, sizeof (glibtop_array));
#ifdef HAVE_PROCFS_H
sprintf(buffer, "/proc/%d/xmap", (int)pid);
sprintf(buffer, "/proc/%d/xmap", (int)pid);
#else
sprintf(buffer, "/proc/%d", (int)pid);
sprintf(buffer, "/proc/%d", (int)pid);
#endif
if((fd = s_open(buffer, O_RDONLY)) < 0)
{
if(errno != EPERM && errno != EACCES)
glibtop_warn_io_r(server, "open (%s)", buffer);
return NULL;
}
if((fd = s_open(buffer, O_RDONLY)) < 0) {
if(errno != EPERM && errno != EACCES)
glibtop_warn_io_r(server, "open (%s)", buffer);
return NULL;
}
#ifdef HAVE_PROCFS_H
if(fstat(fd, &inode) < 0)
{
if(errno != EOVERFLOW)
glibtop_warn_io_r(server, "fstat (%s)", buffer);
/* else call daemon for 64-bit support */
s_close(fd);
return NULL;
}
maps = alloca(inode.st_size);
nmaps = inode.st_size / sizeof(prxmap_t);
if(s_pread(fd, maps, inode.st_size, 0) != inode.st_size)
{
glibtop_warn_io_r(server, "pread (%s)", buffer);
s_close(fd);
return NULL;
}
#else
if(ioctl(fd, PIOCNMAP, &nmaps) < 0)
{
glibtop_warn_io_r(server, "ioctl(%s, PIOCNMAP)", buffer);
s_close(fd);
return NULL;
}
maps = alloca((nmaps + 1) * sizeof(prmap_t));
if(ioctl(fd, PIOCMAP, maps) < 0)
{
glibtop_warn_io_r(server, "ioctl(%s, PIOCMAP)", buffer);
s_close(fd);
return NULL;
}
#endif
if(!(entry = glibtop_malloc_r(server,
nmaps * sizeof(glibtop_map_entry))))
return NULL;
buf->number = nmaps;
buf->size = sizeof(glibtop_map_entry);
buf->total = nmaps * sizeof(glibtop_map_entry);
memset(entry, 0, nmaps * sizeof(glibtop_map_entry));
#if GLIBTOP_SOLARIS_RELEASE >= 560
if(server->_priv->machine.objname && server->_priv->machine.pgrab &&
server->_priv->machine.pfree)
Pr = (server->_priv->machine.pgrab)(pid, 1, &pr_err);
#endif
for(heap = 0,i = 0; i < nmaps; ++i)
{
int len;
entry[i].start = maps[i].pr_vaddr;
entry[i].end = maps[i].pr_vaddr + maps[i].pr_size;
#if GLIBTOP_SOLARIS_RELEASE >= 560
if(maps[i].pr_dev != PRNODEV)
{
entry[i].device = maps[i].pr_dev;
entry[i].inode = maps[i].pr_ino;
entry[i].flags |= _glibtop_sysdeps_map_device;
}
#endif
entry[i].offset = maps[i].OFFSET;
if(maps[i].pr_mflags & MA_READ)
entry[i].perm |= GLIBTOP_MAP_PERM_READ;
if(maps[i].pr_mflags & MA_WRITE)
entry[i].perm |= GLIBTOP_MAP_PERM_WRITE;
if(maps[i].pr_mflags & MA_EXEC)
entry[i].perm |= GLIBTOP_MAP_PERM_EXECUTE;
if(maps[i].pr_mflags & MA_SHARED)
entry[i].perm |= GLIBTOP_MAP_PERM_SHARED;
else
entry[i].perm |= GLIBTOP_MAP_PERM_PRIVATE;
entry[i].flags = _glibtop_sysdeps_map_entry;
#if GLIBTOP_SOLARIS_RELEASE >= 560
if(maps[i].pr_mflags & MA_ANON)
{
if(!heap)
{
++heap;
strcpy(entry[i].filename, "[ heap ]");
}
else
if(i == nmaps - 1)
strcpy(entry[i].filename, "[ stack ]");
else
strcpy(entry[i].filename, "[ anon ]");
entry[i].flags |= (1L << GLIBTOP_MAP_ENTRY_FILENAME);
}
else
if(Pr)
{
server->_priv->machine.objname(Pr, maps[i].pr_vaddr, buffer,
BUFSIZ);
if((len = resolvepath(buffer, entry[i].filename,
GLIBTOP_MAP_FILENAME_LEN)) > 0)
{
entry[i].filename[len] = 0;
entry[i].flags |= (1L << GLIBTOP_MAP_ENTRY_FILENAME);
}
}
#endif
}
#if GLIBTOP_SOLARIS_RELEASE >= 560
if(Pr)
server->_priv->machine.pfree(Pr);
#endif
buf->flags = _glibtop_sysdeps_proc_map;
if(fstat(fd, &inode) < 0) {
if(errno != EOVERFLOW)
glibtop_warn_io_r(server, "fstat (%s)", buffer);
/* else call daemon for 64-bit support */
s_close(fd);
return entry;
return NULL;
}
maps = alloca(inode.st_size);
nmaps = inode.st_size / sizeof(prxmap_t);
if(s_pread(fd, maps, inode.st_size, 0) != inode.st_size) {
glibtop_warn_io_r(server, "pread (%s)", buffer);
s_close(fd);
return NULL;
}
#else
if(ioctl(fd, PIOCNMAP, &nmaps) < 0) {
glibtop_warn_io_r(server, "ioctl(%s, PIOCNMAP)", buffer);
s_close(fd);
return NULL;
}
maps = alloca((nmaps + 1) * sizeof(prmap_t));
if(ioctl(fd, PIOCMAP, maps) < 0) {
glibtop_warn_io_r(server, "ioctl(%s, PIOCMAP)", buffer);
s_close(fd);
return NULL;
}
#endif
if(!(entry = glibtop_malloc_r(server,
nmaps * sizeof(glibtop_map_entry))))
return NULL;
array->number = nmaps;
array->size = sizeof(glibtop_map_entry);
array->total = nmaps * sizeof(glibtop_map_entry);
memset(entry, 0, nmaps * sizeof(glibtop_map_entry));
#if GLIBTOP_SOLARIS_RELEASE >= 560
if(server->_priv->machine.objname && server->_priv->machine.pgrab &&
server->_priv->machine.pfree)
Pr = (server->_priv->machine.pgrab)(pid, 1, &pr_err);
#endif
for(heap = 0,i = 0; i < nmaps; ++i) {
int len;
entry[i].start = maps[i].pr_vaddr;
entry[i].end = maps[i].pr_vaddr + maps[i].pr_size;
#if GLIBTOP_SOLARIS_RELEASE >= 560
if(maps[i].pr_dev != PRNODEV) {
entry[i].device = maps[i].pr_dev;
entry[i].inode = maps[i].pr_ino;
entry[i].flags |= _glibtop_sysdeps_map_device;
}
#endif
entry[i].offset = maps[i].OFFSET;
if(maps[i].pr_mflags & MA_READ)
entry[i].perm |= GLIBTOP_MAP_PERM_READ;
if(maps[i].pr_mflags & MA_WRITE)
entry[i].perm |= GLIBTOP_MAP_PERM_WRITE;
if(maps[i].pr_mflags & MA_EXEC)
entry[i].perm |= GLIBTOP_MAP_PERM_EXECUTE;
if(maps[i].pr_mflags & MA_SHARED)
entry[i].perm |= GLIBTOP_MAP_PERM_SHARED;
else
entry[i].perm |= GLIBTOP_MAP_PERM_PRIVATE;
entry[i].flags = _glibtop_sysdeps_map_entry;
#if GLIBTOP_SOLARIS_RELEASE >= 560
if(maps[i].pr_mflags & MA_ANON) {
if(!heap) {
++heap;
strcpy(entry[i].filename, "[ heap ]");
} else {
if(i == nmaps - 1)
strcpy(entry[i].filename, "[ stack ]");
else
strcpy(entry[i].filename, "[ anon ]");
}
entry[i].flags |= (1L << GLIBTOP_MAP_ENTRY_FILENAME);
} else {
if(Pr) {
server->_priv->machine.objname(Pr, maps[i].pr_vaddr, buffer,
BUFSIZ);
if((len = resolvepath(buffer, entry[i].filename,
GLIBTOP_MAP_FILENAME_LEN)) > 0) {
entry[i].filename[len] = 0;
entry[i].flags |= (1L << GLIBTOP_MAP_ENTRY_FILENAME);
}
#endif
}
}
}
#if GLIBTOP_SOLARIS_RELEASE >= 560
if(Pr)
server->_priv->machine.pfree(Pr);
#endif
array->flags = _glibtop_sysdeps_proc_map;
s_close(fd);
return entry;
}

31
sysdeps/solaris/procmem.c
View File

@@ -24,6 +24,8 @@
#include <glibtop.h>
#include <glibtop/procmem.h>
#include <glibtop_private.h>
static const unsigned long _glibtop_sysdeps_proc_mem =
(1L << GLIBTOP_PROC_MEM_SIZE) + (1L << GLIBTOP_PROC_MEM_VSIZE) +
(1L << GLIBTOP_PROC_MEM_RESIDENT) + (1L << GLIBTOP_PROC_MEM_RSS);
@@ -33,7 +35,9 @@ static const unsigned long _glibtop_sysdeps_proc_mem =
int
glibtop_init_proc_mem_s (glibtop *server)
{
server->sysdeps.proc_mem = _glibtop_sysdeps_proc_mem;
server->sysdeps.proc_mem = _glibtop_sysdeps_proc_mem;
return 0;
}
/* Provides detailed information about a process. */
@@ -42,23 +46,26 @@ int
glibtop_get_proc_mem_s (glibtop *server, glibtop_proc_mem *buf, pid_t pid)
{
#ifdef HAVE_PROCFS_H
struct psinfo psinfo;
struct psinfo psinfo;
#else
struct prpsinfo psinfo;
int pagesize = server->_priv->machine.pagesize;
struct prpsinfo psinfo;
int pagesize = server->_priv->machine.pagesize;
#endif
int retval;
memset (buf, 0, sizeof (glibtop_proc_mem));
memset (buf, 0, sizeof (glibtop_proc_mem));
if(glibtop_get_proc_data_psinfo_s(server, &psinfo, pid))
return;
retval = glibtop_get_proc_data_psinfo_s(server, &psinfo, pid);
if (retval) return retval;
#ifdef HAVE_PROCFS_H
buf->size = buf->vsize = psinfo.pr_size << 10;
buf->resident = buf->rss = psinfo.pr_rssize << 10;
buf->size = buf->vsize = psinfo.pr_size << 10;
buf->resident = buf->rss = psinfo.pr_rssize << 10;
#else
buf->size = buf->vsize = psinfo.pr_size << pagesize << 10;
buf->resident = buf->rss = psinfo.pr_rssize << pagesize << 10;
buf->size = buf->vsize = psinfo.pr_size << pagesize << 10;
buf->resident = buf->rss = psinfo.pr_rssize << pagesize << 10;
#endif
buf->flags = _glibtop_sysdeps_proc_mem;
buf->flags = _glibtop_sysdeps_proc_mem;
return 0;
}

8
sysdeps/solaris/procsegment.c
View File

@@ -31,7 +31,9 @@ static const unsigned long _glibtop_sysdeps_proc_segment = 0;
int
glibtop_init_proc_segment_s (glibtop *server)
{
server->sysdeps.proc_segment = _glibtop_sysdeps_proc_segment;
server->sysdeps.proc_segment = _glibtop_sysdeps_proc_segment;
return 0;
}
/* Provides detailed information about a process. */
@@ -40,5 +42,7 @@ int
glibtop_get_proc_segment_s (glibtop *server, glibtop_proc_segment *buf,
pid_t pid)
{
memset (buf, 0, sizeof (glibtop_proc_segment));
memset (buf, 0, sizeof (glibtop_proc_segment));
return 0;
}

38
sysdeps/solaris/procsignal.c
View File

@@ -34,7 +34,9 @@ static const unsigned long _glibtop_sysdeps_proc_signal =
int
glibtop_init_proc_signal_s (glibtop *server)
{
server->sysdeps.proc_signal = _glibtop_sysdeps_proc_signal;
server->sysdeps.proc_signal = _glibtop_sysdeps_proc_signal;
return 0;
}
/* Provides detailed information about a process. */
@@ -44,31 +46,33 @@ glibtop_get_proc_signal_s (glibtop *server, glibtop_proc_signal *buf,
pid_t pid)
{
#ifdef HAVE_PROCFS_H
struct pstatus pstatus;
struct pstatus pstatus;
#else
struct prstatus pstatus;
struct prstatus pstatus;
#endif
int size;
int retval, size;
memset (buf, 0, sizeof (glibtop_proc_signal));
memset (buf, 0, sizeof (glibtop_proc_signal));
if(glibtop_get_proc_status_s(server, &pstatus, pid))
return;
retval = glibtop_get_proc_status_s(server, &pstatus, pid);
if (retval) return retval;
if(sizeof(buf->signal) < sizeof(sigset_t))
size = sizeof(buf->signal);
else
size = sizeof(sigset_t);
if(sizeof(buf->signal) < sizeof(sigset_t))
size = sizeof(buf->signal);
else
size = sizeof(sigset_t);
memcpy(buf->signal, &pstatus.pr_sigpend, size);
memcpy(buf->signal, &pstatus.pr_sigpend, size);
#ifdef HAVE_PROCFS_H
memcpy(buf->blocked, &pstatus.pr_lwp.pr_lwphold, size);
memcpy(buf->blocked, &pstatus.pr_lwp.pr_lwphold, size);
#else
memcpy(buf->blocked, &pstatus.pr_lwppend, size);
memcpy(buf->blocked, &pstatus.pr_lwppend, size);
#endif
/* Technically, most of this is meaningless on a process level,
but this should be a good enough approximation. */
/* Technically, most of this is meaningless on a process level,
but this should be a good enough approximation. */
buf->flags = _glibtop_sysdeps_proc_signal;
buf->flags = _glibtop_sysdeps_proc_signal;
return 0;
}

71
sysdeps/solaris/procstate.c
View File

@@ -40,7 +40,9 @@ static const unsigned long _glibtop_sysdeps_proc_state =
int
glibtop_init_proc_state_s (glibtop *server)
{
server->sysdeps.proc_state = _glibtop_sysdeps_proc_state;
server->sysdeps.proc_state = _glibtop_sysdeps_proc_state;
return 0;
}
/* Provides detailed information about a process. */
@@ -49,45 +51,56 @@ int
glibtop_get_proc_state_s (glibtop *server, glibtop_proc_state *buf, pid_t pid)
{
#ifdef HAVE_PROCFS_H
struct psinfo psinfo;
struct psinfo psinfo;
#else
struct prpsinfo psinfo;
struct prpsinfo psinfo;
#endif
unsigned state;
int retval;
memset (buf, 0, sizeof (glibtop_proc_state));
memset (buf, 0, sizeof (glibtop_proc_state));
if (glibtop_get_proc_data_psinfo_s (server, &psinfo, pid))
return;
retval = glibtop_get_proc_data_psinfo_s (server, &psinfo, pid);
if (retval) return retval;
buf->uid = psinfo.pr_euid;
buf->gid = psinfo.pr_egid;
buf->ruid = psinfo.pr_uid;
buf->rgid = psinfo.pr_gid;
buf->uid = psinfo.pr_euid;
buf->gid = psinfo.pr_egid;
buf->ruid = psinfo.pr_uid;
buf->rgid = psinfo.pr_gid;
#ifdef HAVE_PROCFS_H
switch(psinfo.pr_lwp.pr_state)
state = psinfo.pr_lwp.pr_state;
#else
switch(psinfo.pr_state)
state = psinfo.pr_state;
#endif
{
case SONPROC:
switch(state) {
case SONPROC:
#ifdef HAVE_PROCFS_H
buf->has_cpu = 1;
buf->processor = psinfo.pr_lwp.pr_onpro;
buf->has_cpu = 1;
buf->processor = psinfo.pr_lwp.pr_onpro;
#endif
case SRUN: buf->state = GLIBTOP_PROCESS_RUNNING;
break;
case SZOMB: buf->state = GLIBTOP_PROCESS_ZOMBIE;
break;
case SSLEEP: buf->state = GLIBTOP_PROCESS_INTERRUPTIBLE;
break;
case SSTOP: buf->state = GLIBTOP_PROCESS_STOPPED;
break;
case SIDL: buf->state = GLIBTOP_PROCESS_UNINTERRUPTIBLE;
}
break;
case SRUN:
buf->state = GLIBTOP_PROCESS_RUNNING;
break;
case SZOMB:
buf->state = GLIBTOP_PROCESS_ZOMBIE;
break;
case SSLEEP:
buf->state = GLIBTOP_PROCESS_INTERRUPTIBLE;
break;
case SSTOP:
buf->state = GLIBTOP_PROCESS_STOPPED;
break;
case SIDL:
buf->state = GLIBTOP_PROCESS_UNINTERRUPTIBLE;
}
#ifdef HAVE_PROCFS_H
buf->last_processor = psinfo.pr_lwp.pr_onpro;
buf->last_processor = psinfo.pr_lwp.pr_onpro;
#endif
strncpy (buf->cmd, psinfo.pr_fname, 39);
strncpy (buf->cmd, psinfo.pr_fname, 39);
buf->flags = _glibtop_sysdeps_proc_state;
buf->flags = _glibtop_sysdeps_proc_state;
return 0;
}

39
sysdeps/solaris/proctime.c
View File

@@ -35,7 +35,9 @@ static const unsigned long _glibtop_sysdeps_proc_time =
int
glibtop_init_proc_time_s (glibtop *server)
{
server->sysdeps.proc_time = _glibtop_sysdeps_proc_time;
server->sysdeps.proc_time = _glibtop_sysdeps_proc_time;
return 0;
}
/* Provides detailed information about a process. */
@@ -44,26 +46,29 @@ int
glibtop_get_proc_time_s (glibtop *server, glibtop_proc_time *buf,
pid_t pid)
{
struct prusage prusage;
struct prusage prusage;
int retval;
memset (buf, 0, sizeof (glibtop_proc_time));
memset (buf, 0, sizeof (glibtop_proc_time));
/* Don't do it for scheduler, we don't want to frighten our users */
/* Don't do it for scheduler, we don't want to frighten our users */
if(pid)
{
if (glibtop_get_proc_data_usage_s (server, &prusage, pid))
return;
if (!pid)
return -GLIBTOP_ERROR_INVALID_ARGUMENT;
buf->start_time = prusage.pr_create.tv_sec;
retval = glibtop_get_proc_data_usage_s (server, &prusage, pid);
if (retval) return retval;
buf->rtime = prusage.pr_rtime.tv_sec * 1E+6 +
prusage.pr_rtime.tv_nsec / 1E+3;
buf->utime = prusage.pr_utime.tv_sec * 1E+6 +
prusage.pr_utime.tv_nsec / 1E+3;
buf->stime = prusage.pr_stime.tv_sec * 1E+6 +
prusage.pr_stime.tv_nsec / 1E+3;
}
buf->start_time = prusage.pr_create.tv_sec;
buf->flags = _glibtop_sysdeps_proc_time;
buf->rtime = prusage.pr_rtime.tv_sec * 1E+6 +
prusage.pr_rtime.tv_nsec / 1E+3;
buf->utime = prusage.pr_utime.tv_sec * 1E+6 +
prusage.pr_utime.tv_nsec / 1E+3;
buf->stime = prusage.pr_stime.tv_sec * 1E+6 +
prusage.pr_stime.tv_nsec / 1E+3;
buf->flags = _glibtop_sysdeps_proc_time;
return 0;
}

85
sysdeps/solaris/procuid.c
View File

@@ -44,8 +44,10 @@ static const unsigned long _glibtop_sysdeps_proc_uid_prcred =
int
glibtop_init_proc_uid_s (glibtop *server)
{
server->sysdeps.proc_uid = _glibtop_sysdeps_proc_uid_psinfo +
_glibtop_sysdeps_proc_uid_prcred;
server->sysdeps.proc_uid = _glibtop_sysdeps_proc_uid_psinfo +
_glibtop_sysdeps_proc_uid_prcred;
return 0;
}
/* Provides detailed information about a process. */
@@ -53,64 +55,67 @@ glibtop_init_proc_uid_s (glibtop *server)
int
glibtop_get_proc_uid_s (glibtop *server, glibtop_proc_uid *buf, pid_t pid)
{
struct prcred prcred;
struct prcred prcred;
#ifdef HAVE_PROCFS_H
struct psinfo psinfo;
gid_t groups[GLIBTOP_MAX_GROUPS];
struct psinfo psinfo;
gid_t groups[GLIBTOP_MAX_GROUPS];
#else
struct prpsinfo psinfo;
gid_t groups[1]; /* dummy for consistent function prototype */
struct prpsinfo psinfo;
gid_t groups[1]; /* dummy for consistent function prototype */
#endif
int retval;
memset (buf, 0, sizeof (glibtop_proc_uid));
memset (buf, 0, sizeof (glibtop_proc_uid));
if (glibtop_get_proc_data_psinfo_s (server, &psinfo, pid))
return;
retval = glibtop_get_proc_data_psinfo_s (server, &psinfo, pid);
if (retval) return retval;
buf->euid = psinfo.pr_euid;
buf->uid = psinfo.pr_uid;
buf->egid = psinfo.pr_egid;
buf->gid = psinfo.pr_gid;
buf->euid = psinfo.pr_euid;
buf->uid = psinfo.pr_uid;
buf->egid = psinfo.pr_egid;
buf->gid = psinfo.pr_gid;
buf->pid = psinfo.pr_pid;
buf->ppid = psinfo.pr_ppid;
buf->pid = psinfo.pr_pid;
buf->ppid = psinfo.pr_ppid;
#ifdef HAVE_PROCFS_H
buf->pgrp = psinfo.pr_pgid;
buf->pgrp = psinfo.pr_pgid;
#else
buf->pgrp = psinfo.pr_pgrp;
buf->pgrp = psinfo.pr_pgrp;
#endif
buf->session = psinfo.pr_sid;
buf->tty = psinfo.pr_ttydev;
buf->session = psinfo.pr_sid;
buf->tty = psinfo.pr_ttydev;
#ifdef HAVE_PROCFS_H
buf->priority = psinfo.pr_lwp.pr_pri;
buf->nice = psinfo.pr_lwp.pr_nice - NZERO;
buf->priority = psinfo.pr_lwp.pr_pri;
buf->nice = psinfo.pr_lwp.pr_nice - NZERO;
#else
buf->priority = psinfo.pr_pri;
buf->nice = psinfo.pr_nice - NZERO;
buf->priority = psinfo.pr_pri;
buf->nice = psinfo.pr_nice - NZERO;
#endif
buf->flags = _glibtop_sysdeps_proc_uid_psinfo;
buf->flags = _glibtop_sysdeps_proc_uid_psinfo;
if(glibtop_get_proc_credentials_s(server, &prcred, groups, pid))
return;
retval = glibtop_get_proc_credentials_s(server, &prcred, groups, pid);
if (retval) return retval;
buf->suid = prcred.pr_suid;
buf->sgid = prcred.pr_sgid;
buf->ngroups = (prcred.pr_ngroups <= GLIBTOP_MAX_GROUPS) ?
prcred.pr_ngroups : GLIBTOP_MAX_GROUPS;
buf->suid = prcred.pr_suid;
buf->sgid = prcred.pr_sgid;
buf->ngroups = (prcred.pr_ngroups <= GLIBTOP_MAX_GROUPS) ?
prcred.pr_ngroups : GLIBTOP_MAX_GROUPS;
#ifdef HAVE_PROCFS_H
if(sizeof(int) == sizeof(gid_t))
memcpy(buf->groups, &groups, buf->ngroups * sizeof(gid_t));
else
{
int i;
if(sizeof(int) == sizeof(gid_t))
memcpy(buf->groups, &groups, buf->ngroups * sizeof(gid_t));
else {
int i;
for(i = 0; i < buf->ngroups; ++i)
buf->groups[i] = groups[i];
}
for(i = 0; i < buf->ngroups; ++i)
buf->groups[i] = groups[i];
}
#endif
buf->flags += _glibtop_sysdeps_proc_uid_prcred;
buf->flags |= _glibtop_sysdeps_proc_uid_prcred;
return 0;
}