Initial revision
This commit is contained in:
1 parent
1a7957fb1e
commit
dffe0da855
207 files changed
+34390
No files matched your search
@@ -0,0 +1,266 @@
|
||||
/*
|
||||
* talk to Data Link Provider Interface aka /dev/dlpi
|
||||
* see: http://docs.hp.com/hpux/onlinedocs/B2355-90139/B2355-90139.html
|
||||
*/
|
||||
#include <errno.h>
|
||||
#include <fcntl.h>
|
||||
#include <memory.h>
|
||||
#include <stdio.h>
|
||||
|
||||
#include <sys/types.h>
|
||||
#include <sys/dlpi.h>
|
||||
#include <sys/dlpi_ext.h>
|
||||
#include <sys/stat.h>
|
||||
#include <sys/stream.h>
|
||||
#include <sys/stropts.h>
|
||||
#include <sys/mib.h>
|
||||
|
||||
#define DLBUF_SIZE 8192
|
||||
|
||||
#define ERRBUF_SIZE 1024
|
||||
|
||||
static int send_req(int fd, char *ptr, int len, char *what, char *ebuf)
|
||||
{
|
||||
struct strbuf ctl;
|
||||
int flags = 0;
|
||||
|
||||
ctl.maxlen = 0;
|
||||
ctl.len = len;
|
||||
ctl.buf = ptr;
|
||||
|
||||
if (putmsg(fd, &ctl, (struct strbuf *) NULL, flags) < 0) {
|
||||
snprintf(ebuf, ERRBUF_SIZE, "send_req: putmsg \"%s\": %s",
|
||||
what, strerror(errno));
|
||||
return -1;
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int recv_ack(int fd, int size, const char *what, char *bufp, char *ebuf)
|
||||
{
|
||||
union DL_primitives *dlp;
|
||||
struct strbuf ctl;
|
||||
int flags = 0;
|
||||
|
||||
ctl.maxlen = DLBUF_SIZE;
|
||||
ctl.len = 0;
|
||||
ctl.buf = bufp;
|
||||
|
||||
if (getmsg(fd, &ctl, (struct strbuf*)NULL, &flags) < 0) {
|
||||
snprintf(ebuf, ERRBUF_SIZE, "recv_ack: %s getmsg: %s",
|
||||
what, strerror(errno));
|
||||
return -1;
|
||||
}
|
||||
|
||||
dlp = (union DL_primitives *)ctl.buf;
|
||||
switch (dlp->dl_primitive) {
|
||||
case DL_INFO_ACK:
|
||||
case DL_BIND_ACK:
|
||||
case DL_OK_ACK:
|
||||
case DL_HP_PPA_ACK:
|
||||
case DL_HP_INFO_ACK:
|
||||
case DL_GET_STATISTICS_ACK:
|
||||
break;
|
||||
|
||||
case DL_ERROR_ACK:
|
||||
switch (dlp->error_ack.dl_errno) {
|
||||
|
||||
case DL_SYSERR:
|
||||
snprintf(ebuf, ERRBUF_SIZE, "recv_ack: %s: system error - %s",
|
||||
what, strerror(dlp->error_ack.dl_unix_errno));
|
||||
break;
|
||||
|
||||
default:
|
||||
snprintf(ebuf, ERRBUF_SIZE, "recv_ack: %s: dl error - %d",
|
||||
what, dlp->error_ack.dl_errno);
|
||||
break;
|
||||
}
|
||||
return -1;
|
||||
default:
|
||||
snprintf(ebuf, ERRBUF_SIZE,
|
||||
"recv_ack: %s: unexpected primitive ack %d",
|
||||
what, dlp->dl_primitive);
|
||||
return -1;
|
||||
}
|
||||
|
||||
if (ctl.len < size) {
|
||||
snprintf(ebuf, ERRBUF_SIZE,
|
||||
"recv_ack: %s: ack too small (%d < %d)",
|
||||
what, ctl.len, size);
|
||||
return -1;
|
||||
}
|
||||
|
||||
return ctl.len;
|
||||
}
|
||||
|
||||
static int dl_attach_req(int fd, uint32_t ppa, char *ebuf)
|
||||
{
|
||||
dl_attach_req_t req;
|
||||
|
||||
req.dl_primitive = DL_ATTACH_REQ;
|
||||
req.dl_ppa = ppa;
|
||||
|
||||
return send_req(fd, (char *)&req, sizeof(req), "attach", ebuf);
|
||||
}
|
||||
|
||||
static int dl_bind_req(int fd, uint32_t sap, char *ebuf)
|
||||
{
|
||||
dl_bind_req_t req;
|
||||
|
||||
memset((char *)&req, 0, sizeof(req));
|
||||
req.dl_primitive = DL_BIND_REQ;
|
||||
|
||||
req.dl_max_conind = 1;
|
||||
/* 22 == INSAP, see HP-UX DLPI Programmer's Guide */
|
||||
req.dl_sap = 22;
|
||||
req.dl_service_mode = DL_HP_RAWDLS;
|
||||
req.dl_service_mode = DL_CODLS;
|
||||
|
||||
return send_req(fd, (char *)&req, sizeof(req), "bind", ebuf);
|
||||
}
|
||||
|
||||
static int dl_bind_ack(int fd, char *bufp, char *ebuf)
|
||||
{
|
||||
return recv_ack(fd, DL_BIND_ACK_SIZE, "bind", bufp, ebuf);
|
||||
}
|
||||
|
||||
static int dl_ok_ack(int fd, const char *what, char *bufp, char *ebuf)
|
||||
{
|
||||
return recv_ack(fd, DL_OK_ACK_SIZE, what, bufp, ebuf);
|
||||
}
|
||||
|
||||
static int dl_info_req(int fd, char *ebuf)
|
||||
{
|
||||
dl_info_req_t req;
|
||||
|
||||
req.dl_primitive = DL_INFO_REQ;
|
||||
|
||||
return send_req(fd, (char *)&req, sizeof(req), "info", ebuf);
|
||||
}
|
||||
|
||||
static int dl_info_ack(int fd, char *bufp, char *ebuf)
|
||||
{
|
||||
return recv_ack(fd, DL_INFO_ACK_SIZE, "info", bufp, ebuf);
|
||||
}
|
||||
|
||||
static int dl_hp_info_req(int fd, char *ebuf)
|
||||
{
|
||||
dl_hp_info_req_t req;
|
||||
|
||||
req.dl_primitive = DL_HP_INFO_REQ;
|
||||
|
||||
return send_req(fd, (char *)&req, sizeof(req), "hpinfo", ebuf);
|
||||
}
|
||||
|
||||
static int dl_hp_info_ack(int fd, char *bufp, char *ebuf)
|
||||
{
|
||||
return recv_ack(fd, DL_HP_INFO_ACK_SIZE, "hpinfo", bufp, ebuf);
|
||||
}
|
||||
|
||||
static int dl_stats_req(int fd, char *ebuf)
|
||||
{
|
||||
dl_get_statistics_req_t req;
|
||||
|
||||
req.dl_primitive = DL_GET_STATISTICS_REQ;
|
||||
|
||||
return send_req(fd, (char *)&req, sizeof(req), "stats", ebuf);
|
||||
}
|
||||
|
||||
static int dl_stats_ack(int fd, char *bufp, char *ebuf)
|
||||
{
|
||||
return recv_ack(fd, DL_GET_STATISTICS_ACK_SIZE, "stats", bufp, ebuf);
|
||||
}
|
||||
|
||||
static int dl_open(int ppa, char *ebuf)
|
||||
{
|
||||
char *dev = "/dev/dlpi";
|
||||
int fd = -1;
|
||||
dl_info_ack_t *infop;
|
||||
uint32_t buf[DLBUF_SIZE];
|
||||
char dname[128];
|
||||
|
||||
if ((fd = open(dev, O_RDWR)) < 0) {
|
||||
snprintf(ebuf, sizeof(ebuf),
|
||||
"failed to open %s: %s", dev, strerror(errno));
|
||||
return -1;
|
||||
}
|
||||
|
||||
if (dl_info_req(fd, ebuf) < 0 ||
|
||||
dl_info_ack(fd, (char *)buf, ebuf) < 0) {
|
||||
return -1;
|
||||
}
|
||||
|
||||
infop = &((union DL_primitives *)buf)->info_ack;
|
||||
|
||||
if (infop->dl_provider_style == DL_STYLE2 &&
|
||||
(dl_attach_req(fd, ppa, ebuf) < 0 ||
|
||||
dl_ok_ack(fd, "attach", (char *)buf, ebuf) < 0))
|
||||
{
|
||||
return -1;
|
||||
}
|
||||
|
||||
if (dl_bind_req(fd, 0, ebuf) < 0 ||
|
||||
dl_bind_ack(fd, (char *)buf, ebuf) < 0)
|
||||
{
|
||||
return -1;
|
||||
}
|
||||
|
||||
return fd;
|
||||
}
|
||||
|
||||
static int dl_get_hp_info(int fd, char *bufp, char *ebuf)
|
||||
{
|
||||
dl_hp_info_ack_t *ip;
|
||||
|
||||
if ((dl_hp_info_req(fd, ebuf) < 0) ||
|
||||
(dl_hp_info_ack(fd, bufp, ebuf) < 0)) {
|
||||
return -1;
|
||||
}
|
||||
|
||||
ip = (dl_hp_info_ack_t *)bufp;
|
||||
if (ip->dl_primitive != DL_HP_INFO_ACK) {
|
||||
return -1;
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int dl_get_stats(int fd, char *bufp, char *ebuf)
|
||||
{
|
||||
dl_get_statistics_ack_t *ip;
|
||||
|
||||
if ((dl_stats_req(fd, ebuf) < 0) ||
|
||||
(dl_stats_ack(fd, bufp, ebuf) < 0)) {
|
||||
return -1;
|
||||
}
|
||||
|
||||
ip = (dl_get_statistics_ack_t *)bufp;
|
||||
if (ip->dl_primitive != DL_GET_STATISTICS_ACK) {
|
||||
return -1;
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
int hpux_get_mib_ifentry(int ppa, mib_ifEntry *mib)
|
||||
{
|
||||
int fd, status=0;
|
||||
char ebuf[ERRBUF_SIZE];
|
||||
uint32_t buf[DLBUF_SIZE];
|
||||
|
||||
if ((fd = dl_open(ppa, ebuf)) < 0) {
|
||||
return errno;
|
||||
}
|
||||
|
||||
if (dl_get_stats(fd, (char *)buf, ebuf) >= 0) {
|
||||
dl_get_statistics_ack_t *st = (dl_get_statistics_ack_t *)buf;
|
||||
memcpy(mib, (u_char *)buf + st->dl_stat_offset, sizeof(*mib));
|
||||
}
|
||||
else {
|
||||
status = errno;
|
||||
}
|
||||
|
||||
close(fd);
|
||||
return status;
|
||||
}
|
||||
@@ -0,0 +1,709 @@
|
||||
#include "sigar.h"
|
||||
#include "sigar_private.h"
|
||||
#include "sigar_os.h"
|
||||
#include "sigar_util.h"
|
||||
|
||||
#include <sys/dk.h>
|
||||
#include <errno.h>
|
||||
|
||||
int sigar_os_open(sigar_t **sigar)
|
||||
{
|
||||
*sigar = malloc(sizeof(**sigar));
|
||||
|
||||
/* does not change while system is running */
|
||||
pstat_getstatic(&(*sigar)->pstatic,
|
||||
sizeof((*sigar)->pstatic),
|
||||
1, 0);
|
||||
|
||||
(*sigar)->proctab = NULL;
|
||||
|
||||
(*sigar)->ticks = sysconf(_SC_CLK_TCK);
|
||||
|
||||
(*sigar)->last_pid = -1;
|
||||
|
||||
(*sigar)->pinfo = NULL;
|
||||
|
||||
return SIGAR_OK;
|
||||
|
||||
}
|
||||
|
||||
int sigar_os_close(sigar_t *sigar)
|
||||
{
|
||||
if (sigar->proctab) {
|
||||
free(sigar->proctab);
|
||||
}
|
||||
if (sigar->pinfo) {
|
||||
free(sigar->pinfo);
|
||||
}
|
||||
free(sigar);
|
||||
return SIGAR_OK;
|
||||
}
|
||||
|
||||
char *sigar_os_error_string(int err)
|
||||
{
|
||||
return NULL;
|
||||
}
|
||||
|
||||
int sigar_mem_get(sigar_t *sigar, sigar_mem_t *mem)
|
||||
{
|
||||
struct pst_dynamic stats;
|
||||
sigar_uint64_t pagesize = sigar->pstatic.page_size;
|
||||
|
||||
mem->total = sigar->pstatic.physical_memory * pagesize;
|
||||
|
||||
sigar_mem_calc_ram(sigar, mem);
|
||||
|
||||
pstat_getdynamic(&stats, sizeof(stats), 1, 0);
|
||||
|
||||
mem->free = stats.psd_free * pagesize;
|
||||
mem->used = mem->total - mem->free;
|
||||
|
||||
/*XXX*/
|
||||
mem->shared = mem->buffer = mem->cached = 0;
|
||||
|
||||
return SIGAR_OK;
|
||||
}
|
||||
|
||||
int sigar_swap_get(sigar_t *sigar, sigar_swap_t *swap)
|
||||
{
|
||||
struct pst_swapinfo swapinfo;
|
||||
int i=0;
|
||||
|
||||
swap->total = swap->free = 0;
|
||||
|
||||
while (pstat_getswap(&swapinfo, sizeof(swapinfo), 1, i++) > 0) {
|
||||
swapinfo.pss_nfpgs *= 4; /* nfpgs is in 512 byte blocks */
|
||||
|
||||
if (swapinfo.pss_nblksenabled == 0) {
|
||||
swapinfo.pss_nblksenabled = swapinfo.pss_nfpgs;
|
||||
}
|
||||
|
||||
swap->total += swapinfo.pss_nblksenabled;
|
||||
swap->free += swapinfo.pss_nfpgs;
|
||||
}
|
||||
|
||||
swap->used = swap->total - swap->free;
|
||||
|
||||
return SIGAR_OK;
|
||||
}
|
||||
|
||||
int sigar_cpu_get(sigar_t *sigar, sigar_cpu_t *cpu)
|
||||
{
|
||||
int i;
|
||||
struct pst_dynamic stats;
|
||||
|
||||
pstat_getdynamic(&stats, sizeof(stats), 1, 0);
|
||||
sigar->ncpu = stats.psd_proc_cnt;
|
||||
|
||||
cpu->user = stats.psd_cpu_time[CP_USER];
|
||||
cpu->sys = stats.psd_cpu_time[CP_SYS] + stats.psd_cpu_time[CP_SSYS];
|
||||
cpu->nice = stats.psd_cpu_time[CP_NICE];
|
||||
cpu->idle = stats.psd_cpu_time[CP_IDLE];
|
||||
|
||||
cpu->total = 0;
|
||||
|
||||
/* states above plus CP_BLOCK, CP_SWAIT, etc. (see sys/dk.h) */
|
||||
for (i=0; i<CPUSTATES; i++) {
|
||||
cpu->total += stats.psd_cpu_time[i];
|
||||
}
|
||||
|
||||
return SIGAR_OK;
|
||||
}
|
||||
|
||||
int sigar_cpu_list_get(sigar_t *sigar, sigar_cpu_list_t *cpulist)
|
||||
{
|
||||
int i;
|
||||
struct pst_dynamic stats;
|
||||
|
||||
pstat_getdynamic(&stats, sizeof(stats), 1, 0);
|
||||
sigar->ncpu = stats.psd_proc_cnt;
|
||||
|
||||
sigar_cpu_list_create(cpulist);
|
||||
|
||||
for (i=0; i<sigar->ncpu; i++) {
|
||||
int j;
|
||||
sigar_cpu_t *cpu;
|
||||
struct pst_processor proc;
|
||||
|
||||
if (pstat_getprocessor(&proc, sizeof(proc), 1, i) < 0) {
|
||||
continue;
|
||||
}
|
||||
|
||||
SIGAR_CPU_LIST_GROW(cpulist);
|
||||
|
||||
cpu = &cpulist->data[cpulist->number++];
|
||||
|
||||
cpu->user = proc.psp_cpu_time[CP_USER];
|
||||
cpu->sys = proc.psp_cpu_time[CP_SYS] + proc.psp_cpu_time[CP_SSYS];
|
||||
cpu->nice = proc.psp_cpu_time[CP_NICE];
|
||||
cpu->idle = proc.psp_cpu_time[CP_IDLE];
|
||||
|
||||
cpu->total = 0;
|
||||
|
||||
for (j=0; j<CPUSTATES; j++) {
|
||||
cpu->total += proc.psp_cpu_time[j];
|
||||
}
|
||||
}
|
||||
|
||||
return SIGAR_OK;
|
||||
}
|
||||
|
||||
int sigar_uptime_get(sigar_t *sigar,
|
||||
sigar_uptime_t *uptime)
|
||||
{
|
||||
uptime->uptime = time(NULL) - sigar->pstatic.boot_time;
|
||||
uptime->idletime = 0; /*XXX*/;
|
||||
|
||||
return SIGAR_OK;
|
||||
}
|
||||
|
||||
int sigar_loadavg_get(sigar_t *sigar,
|
||||
sigar_loadavg_t *loadavg)
|
||||
{
|
||||
struct pst_dynamic stats;
|
||||
|
||||
pstat_getdynamic(&stats, sizeof(stats), 1, 0);
|
||||
|
||||
loadavg->loadavg[0] = stats.psd_avg_1_min;
|
||||
loadavg->loadavg[1] = stats.psd_avg_5_min;
|
||||
loadavg->loadavg[2] = stats.psd_avg_15_min;
|
||||
|
||||
return SIGAR_OK;
|
||||
}
|
||||
|
||||
int sigar_proc_list_get(sigar_t *sigar,
|
||||
sigar_proc_list_t *proclist)
|
||||
{
|
||||
int n;
|
||||
|
||||
if (!sigar->proctab) {
|
||||
/* malloc this only once per-sigar_t as the size will not change */
|
||||
sigar->proctab = malloc(sizeof(*sigar->proctab) *
|
||||
sigar->pstatic.max_proc);
|
||||
}
|
||||
|
||||
n = pstat_getproc(sigar->proctab, sizeof(*sigar->proctab),
|
||||
sigar->pstatic.max_proc, 0);
|
||||
|
||||
proclist->number = 0;
|
||||
proclist->size = n;
|
||||
proclist->data = malloc(sizeof(*(proclist->data)) * n);
|
||||
|
||||
for (n=0; n<proclist->size; n++) {
|
||||
proclist->data[proclist->number++] =
|
||||
sigar->proctab[n].pst_pid;
|
||||
}
|
||||
|
||||
return SIGAR_OK;
|
||||
}
|
||||
|
||||
int sigar_proc_stat_get(sigar_t *sigar,
|
||||
sigar_proc_stat_t *procstat)
|
||||
{
|
||||
int status = /* XXX optimize */
|
||||
sigar_proc_count(sigar, &procstat->total);
|
||||
|
||||
return status;
|
||||
}
|
||||
|
||||
static int sigar_pstat_getproc(sigar_t *sigar, sigar_pid_t pid)
|
||||
{
|
||||
int status, num;
|
||||
time_t timenow = time(NULL);
|
||||
|
||||
if (sigar->pinfo == NULL) {
|
||||
sigar->pinfo = malloc(sizeof(*sigar->pinfo));
|
||||
}
|
||||
|
||||
if (sigar->last_pid == pid) {
|
||||
if ((timenow - sigar->last_getprocs) < SIGAR_LAST_PROC_EXPIRE) {
|
||||
return SIGAR_OK;
|
||||
}
|
||||
}
|
||||
|
||||
sigar->last_pid = pid;
|
||||
sigar->last_getprocs = timenow;
|
||||
|
||||
if (pstat_getproc(sigar->pinfo,
|
||||
sizeof(*sigar->pinfo),
|
||||
0, pid) == -1)
|
||||
{
|
||||
return ESRCH;
|
||||
}
|
||||
|
||||
return SIGAR_OK;
|
||||
}
|
||||
|
||||
int sigar_proc_mem_get(sigar_t *sigar, sigar_pid_t pid,
|
||||
sigar_proc_mem_t *procmem)
|
||||
{
|
||||
int pagesize = sigar->pstatic.page_size;
|
||||
int status = sigar_pstat_getproc(sigar, pid);
|
||||
struct pst_status *pinfo = sigar->pinfo;
|
||||
|
||||
if (status != SIGAR_OK) {
|
||||
return status;
|
||||
}
|
||||
|
||||
procmem->size =
|
||||
pinfo->pst_tsize + /* text */
|
||||
pinfo->pst_dsize + /* data */
|
||||
pinfo->pst_ssize; /* stack */
|
||||
|
||||
procmem->size *= pagesize;
|
||||
|
||||
procmem->vsize =
|
||||
pinfo->pst_vtsize + /* text */
|
||||
pinfo->pst_vdsize + /* data */
|
||||
pinfo->pst_vssize; /* stack */
|
||||
|
||||
procmem->vsize *= pagesize;
|
||||
|
||||
procmem->rss = pinfo->pst_rssize * pagesize;
|
||||
|
||||
procmem->share = pinfo->pst_shmsize * pagesize;
|
||||
|
||||
return SIGAR_OK;
|
||||
}
|
||||
|
||||
int sigar_proc_cred_get(sigar_t *sigar, sigar_pid_t pid,
|
||||
sigar_proc_cred_t *proccred)
|
||||
{
|
||||
int status = sigar_pstat_getproc(sigar, pid);
|
||||
struct pst_status *pinfo = sigar->pinfo;
|
||||
|
||||
if (status != SIGAR_OK) {
|
||||
return status;
|
||||
}
|
||||
|
||||
proccred->uid = pinfo->pst_uid;
|
||||
proccred->gid = pinfo->pst_gid;
|
||||
proccred->euid = pinfo->pst_euid;
|
||||
proccred->egid = pinfo->pst_egid;
|
||||
|
||||
return SIGAR_OK;
|
||||
}
|
||||
|
||||
int sigar_proc_time_get(sigar_t *sigar, sigar_pid_t pid,
|
||||
sigar_proc_time_t *proctime)
|
||||
{
|
||||
int status = sigar_pstat_getproc(sigar, pid);
|
||||
struct pst_status *pinfo = sigar->pinfo;
|
||||
|
||||
if (status != SIGAR_OK) {
|
||||
return status;
|
||||
}
|
||||
|
||||
proctime->start_time = pinfo->pst_start;
|
||||
proctime->start_time *= 1000;
|
||||
proctime->utime = pinfo->pst_utime;
|
||||
proctime->stime = pinfo->pst_stime;
|
||||
|
||||
return SIGAR_OK;
|
||||
}
|
||||
|
||||
int sigar_proc_state_get(sigar_t *sigar, sigar_pid_t pid,
|
||||
sigar_proc_state_t *procstate)
|
||||
{
|
||||
int status = sigar_pstat_getproc(sigar, pid);
|
||||
struct pst_status *pinfo = sigar->pinfo;
|
||||
|
||||
if (status != SIGAR_OK) {
|
||||
return status;
|
||||
}
|
||||
|
||||
|
||||
SIGAR_SSTRCPY(procstate->name, pinfo->pst_ucomm);
|
||||
procstate->ppid = pinfo->pst_ppid;
|
||||
procstate->tty = makedev(pinfo->pst_term.psd_major,
|
||||
pinfo->pst_term.psd_minor);
|
||||
procstate->priority = pinfo->pst_pri;
|
||||
procstate->nice = pinfo->pst_nice;
|
||||
|
||||
switch (pinfo->pst_stat) {
|
||||
case PS_SLEEP:
|
||||
procstate->state = 'S';
|
||||
break;
|
||||
case PS_RUN:
|
||||
procstate->state = 'R';
|
||||
break;
|
||||
case PS_STOP:
|
||||
procstate->state = 'T';
|
||||
break;
|
||||
case PS_ZOMBIE:
|
||||
procstate->state = 'Z';
|
||||
break;
|
||||
case PS_IDLE:
|
||||
procstate->state = 'D';
|
||||
break;
|
||||
}
|
||||
|
||||
return SIGAR_OK;
|
||||
}
|
||||
|
||||
/* XXX: could be useful elsewhere */
|
||||
static char *sigar_getword(char **line, char stop)
|
||||
{
|
||||
char *pos = *line;
|
||||
int len;
|
||||
char *res;
|
||||
|
||||
while ((*pos != stop) && *pos) {
|
||||
++pos;
|
||||
}
|
||||
|
||||
len = pos - *line;
|
||||
res = (char *)malloc(len + 1);
|
||||
memcpy(res, *line, len);
|
||||
res[len] = 0;
|
||||
|
||||
if (stop) {
|
||||
while (*pos == stop) {
|
||||
++pos;
|
||||
}
|
||||
}
|
||||
|
||||
*line = pos;
|
||||
|
||||
return res;
|
||||
}
|
||||
|
||||
/*
|
||||
* XXX: pst_cmd is only 64 chars of the command args.
|
||||
* according to HP forums there isn't a way to get them
|
||||
* all if > 64
|
||||
*/
|
||||
int sigar_proc_args_get(sigar_t *sigar, sigar_pid_t pid,
|
||||
sigar_proc_args_t *procargs)
|
||||
{
|
||||
char *args, *arg;
|
||||
struct pst_status status;
|
||||
|
||||
if (pstat_getproc(&status, sizeof(status), 0, pid) == -1) {
|
||||
return ESRCH;
|
||||
}
|
||||
|
||||
args = status.pst_cmd;
|
||||
sigar_proc_args_create(procargs);
|
||||
|
||||
while (*args && (arg = sigar_getword(&args, ' '))) {
|
||||
SIGAR_PROC_ARGS_GROW(procargs);
|
||||
procargs->data[procargs->number++] = arg;
|
||||
}
|
||||
|
||||
return SIGAR_OK;
|
||||
}
|
||||
|
||||
int sigar_proc_env_get(sigar_t *sigar, sigar_pid_t pid,
|
||||
sigar_proc_env_t *procenv)
|
||||
{
|
||||
return SIGAR_ENOTIMPL;
|
||||
}
|
||||
|
||||
int sigar_proc_fd_get(sigar_t *sigar, sigar_pid_t pid,
|
||||
sigar_proc_fd_t *procfd)
|
||||
{
|
||||
struct pst_status status;
|
||||
int idx, i, n;
|
||||
struct pst_fileinfo psf[16];
|
||||
|
||||
procfd->total = 0;
|
||||
|
||||
if (pstat_getproc(&status, sizeof(status), 0, pid) == -1) {
|
||||
return ESRCH;
|
||||
}
|
||||
|
||||
/* man pstat_getfile for index splaination */
|
||||
idx = (status.pst_idx << 16) | (0 & 0xffff);
|
||||
|
||||
while ((n = pstat_getfile(psf, sizeof(psf[0]),
|
||||
sizeof(psf)/sizeof(psf[0]),
|
||||
idx)) > 0)
|
||||
{
|
||||
procfd->total += n;
|
||||
idx = psf[n-1].psf_idx + 1;
|
||||
}
|
||||
|
||||
if (n == -1) {
|
||||
return errno;
|
||||
}
|
||||
|
||||
return SIGAR_OK;
|
||||
}
|
||||
|
||||
int sigar_proc_exe_get(sigar_t *sigar, sigar_pid_t pid,
|
||||
sigar_proc_exe_t *procexe)
|
||||
{
|
||||
return SIGAR_ENOTIMPL;
|
||||
}
|
||||
|
||||
#include <mntent.h>
|
||||
|
||||
int sigar_os_fs_type_get(sigar_file_system_t *fsp)
|
||||
{
|
||||
char *type = fsp->sys_type_name;
|
||||
|
||||
switch (*type) {
|
||||
case 'h':
|
||||
if (strEQ(type, "hfs")) {
|
||||
fsp->type = SIGAR_FSTYPE_LOCAL_DISK;
|
||||
}
|
||||
break;
|
||||
case 'v':
|
||||
if (strEQ(type, "vxfs")) {
|
||||
fsp->type = SIGAR_FSTYPE_LOCAL_DISK;
|
||||
}
|
||||
break;
|
||||
case 'c':
|
||||
if (strEQ(type, "cdfs")) {
|
||||
fsp->type = SIGAR_FSTYPE_CDROM;
|
||||
}
|
||||
break;
|
||||
}
|
||||
|
||||
return fsp->type;
|
||||
}
|
||||
|
||||
int sigar_file_system_list_get(sigar_t *sigar,
|
||||
sigar_file_system_list_t *fslist)
|
||||
{
|
||||
struct mntent ent;
|
||||
char buf[1025];
|
||||
|
||||
FILE *fp;
|
||||
sigar_file_system_t *fsp;
|
||||
|
||||
if (!(fp = setmntent(MNT_CHECKLIST, "r"))) {
|
||||
return errno;
|
||||
}
|
||||
|
||||
sigar_file_system_list_create(fslist);
|
||||
|
||||
while (getmntent_r(fp, &ent, buf, sizeof(buf)) == 0) {
|
||||
if ((*(ent.mnt_type) == 's') &&
|
||||
strEQ(ent.mnt_type, "swap"))
|
||||
{
|
||||
/*
|
||||
* in this case, devname == "...", for
|
||||
* which statfs chokes on. so skip it.
|
||||
* also notice hpux df command has no swap info.
|
||||
*/
|
||||
continue;
|
||||
}
|
||||
|
||||
SIGAR_FILE_SYSTEM_LIST_GROW(fslist);
|
||||
|
||||
fsp = &fslist->data[fslist->number++];
|
||||
|
||||
SIGAR_SSTRCPY(fsp->dir_name, ent.mnt_dir);
|
||||
SIGAR_SSTRCPY(fsp->dev_name, ent.mnt_fsname);
|
||||
SIGAR_SSTRCPY(fsp->sys_type_name, ent.mnt_type);
|
||||
sigar_fs_type_init(fsp);
|
||||
}
|
||||
|
||||
endmntent(fp);
|
||||
|
||||
return SIGAR_OK;
|
||||
}
|
||||
|
||||
/* XXX this is exactly the same as linux and solaris is darn close */
|
||||
#include <sys/vfs.h>
|
||||
|
||||
#define SIGAR_FS_BLOCKS_TO_BYTES(buf, f) \
|
||||
((buf.f * (buf.f_bsize / 512)) >> 1)
|
||||
|
||||
int sigar_file_system_usage_get(sigar_t *sigar,
|
||||
const char *dirname,
|
||||
sigar_file_system_usage_t *fsusage)
|
||||
{
|
||||
struct statfs buf;
|
||||
|
||||
if (statfs(dirname, &buf) != 0) {
|
||||
return errno;
|
||||
}
|
||||
|
||||
fsusage->total = SIGAR_FS_BLOCKS_TO_BYTES(buf, f_blocks);
|
||||
fsusage->free = SIGAR_FS_BLOCKS_TO_BYTES(buf, f_bfree);
|
||||
fsusage->avail = SIGAR_FS_BLOCKS_TO_BYTES(buf, f_bavail);
|
||||
fsusage->files = buf.f_files;
|
||||
fsusage->free_files = buf.f_ffree;
|
||||
fsusage->use_percent = sigar_file_system_usage_calc_used(sigar, fsusage);
|
||||
|
||||
return SIGAR_OK;
|
||||
}
|
||||
|
||||
int sigar_cpu_infos_get(sigar_t *sigar,
|
||||
sigar_cpu_infos_t *cpu_infos)
|
||||
{
|
||||
int i;
|
||||
struct pst_dynamic stats;
|
||||
|
||||
pstat_getdynamic(&stats, sizeof(stats), 1, 0);
|
||||
sigar->ncpu = stats.psd_proc_cnt;
|
||||
|
||||
sigar_cpu_infos_create(cpu_infos);
|
||||
|
||||
for (i=0; i<sigar->ncpu; i++) {
|
||||
sigar_cpu_info_t *info;
|
||||
struct pst_processor proc;
|
||||
|
||||
if (pstat_getprocessor(&proc, sizeof(proc), 1, i) < 0) {
|
||||
perror("pstat_getprocessor");
|
||||
continue;
|
||||
}
|
||||
|
||||
SIGAR_CPU_INFOS_GROW(cpu_infos);
|
||||
|
||||
info = &cpu_infos->data[cpu_infos->number++];
|
||||
|
||||
SIGAR_SSTRCPY(info->vendor, "HP"); /*XXX*/
|
||||
SIGAR_SSTRCPY(info->model, "PA RISC"); /*XXX*/
|
||||
info->mhz = sigar->ticks * proc.psp_iticksperclktick / 1000000;
|
||||
info->cache_size = -1; /*XXX*/
|
||||
}
|
||||
|
||||
return SIGAR_OK;
|
||||
}
|
||||
|
||||
int sigar_net_route_list_get(sigar_t *sigar,
|
||||
sigar_net_route_list_t *routelist)
|
||||
{
|
||||
int fd, count, i;
|
||||
unsigned int len;
|
||||
struct nmparms parms;
|
||||
mib_ipRouteEnt *routes;
|
||||
sigar_net_route_t *route;
|
||||
|
||||
if ((fd = open_mib("/dev/ip", O_RDWR, 0, 0)) < 0) {
|
||||
return errno;
|
||||
}
|
||||
|
||||
len = sizeof(count);
|
||||
parms.objid = ID_ipRouteNumEnt;
|
||||
parms.buffer = &count;
|
||||
parms.len = &len;
|
||||
|
||||
if (get_mib_info(fd, &parms) < 0) {
|
||||
return errno;
|
||||
}
|
||||
|
||||
len = count * sizeof(*routes);
|
||||
routes = malloc(len);
|
||||
|
||||
parms.objid = ID_ipRouteTable;
|
||||
parms.buffer = routes;
|
||||
parms.len = &len;
|
||||
|
||||
if (get_mib_info(fd, &parms) < 0) {
|
||||
free(routes);
|
||||
return errno;
|
||||
}
|
||||
|
||||
routelist->size = routelist->number = 0;
|
||||
|
||||
sigar_net_route_list_create(routelist);
|
||||
|
||||
for (i=0; i<count; i++) {
|
||||
mib_ipRouteEnt *ent = &routes[i];
|
||||
|
||||
SIGAR_NET_ROUTE_LIST_GROW(routelist);
|
||||
|
||||
route = &routelist->data[routelist->number++];
|
||||
SIGAR_ZERO(route); /* XXX: other fields */
|
||||
|
||||
route->destination = ent->Dest;
|
||||
route->mask = ent->Mask;
|
||||
route->gateway = ent->NextHop;
|
||||
}
|
||||
|
||||
free(routes);
|
||||
close_mib(fd);
|
||||
|
||||
return SIGAR_OK;
|
||||
}
|
||||
|
||||
static int get_mib_ifstat(sigar_t *sigar,
|
||||
const char *name,
|
||||
mib_ifEntry *mib)
|
||||
{
|
||||
int fd, count, i;
|
||||
unsigned int len;
|
||||
nmapi_phystat *stat;
|
||||
struct nmparms parms;
|
||||
|
||||
if ((fd = open_mib("/dev/ip", O_RDWR, 0, 0)) < 0) {
|
||||
return errno;
|
||||
}
|
||||
|
||||
len = sizeof(count);
|
||||
parms.objid = ID_ifNumber;
|
||||
parms.buffer = &count;
|
||||
parms.len = &len;
|
||||
|
||||
if (get_mib_info(fd, &parms) < 0) {
|
||||
return errno;
|
||||
}
|
||||
|
||||
len = sizeof(nmapi_phystat) * count;
|
||||
|
||||
if (sigar->ifconf_len < len) {
|
||||
sigar->ifconf_buf = realloc(sigar->ifconf_buf, len);
|
||||
sigar->ifconf_len = len;
|
||||
}
|
||||
|
||||
if (get_physical_stat(sigar->ifconf_buf, &len) < 0) {
|
||||
close_mib(fd);
|
||||
return errno;
|
||||
}
|
||||
|
||||
for (i=0, stat = (nmapi_phystat *)sigar->ifconf_buf;
|
||||
i<count;
|
||||
i++, stat++)
|
||||
{
|
||||
if (strEQ(stat->nm_device, name)) {
|
||||
memcpy(mib, &stat->if_entry, sizeof(*mib));
|
||||
close_mib(fd);
|
||||
return SIGAR_OK;
|
||||
}
|
||||
}
|
||||
|
||||
close_mib(fd);
|
||||
return ENXIO;
|
||||
}
|
||||
|
||||
int sigar_net_interface_stat_get(sigar_t *sigar, const char *name,
|
||||
sigar_net_interface_stat_t *ifstat)
|
||||
{
|
||||
int status;
|
||||
mib_ifEntry mib;
|
||||
|
||||
status = get_mib_ifstat(sigar, name, &mib);
|
||||
|
||||
if (status != SIGAR_OK) {
|
||||
return status;
|
||||
}
|
||||
|
||||
ifstat->rx_bytes = mib.ifInOctets;
|
||||
ifstat->rx_packets = mib.ifInUcastPkts + mib.ifInNUcastPkts;
|
||||
ifstat->rx_errors = mib.ifInErrors;
|
||||
ifstat->rx_dropped = mib.ifInDiscards;
|
||||
ifstat->rx_overruns = 0; /*XXX*/
|
||||
ifstat->rx_frame = 0; /*XXX*/
|
||||
|
||||
ifstat->tx_bytes = mib.ifOutOctets;
|
||||
ifstat->tx_packets = mib.ifOutUcastPkts + mib.ifOutNUcastPkts;
|
||||
ifstat->tx_errors = mib.ifOutErrors;
|
||||
ifstat->tx_dropped = mib.ifOutDiscards;
|
||||
ifstat->tx_overruns = 0; /*XXX*/
|
||||
ifstat->tx_collisions = 0; /*XXX*/
|
||||
ifstat->tx_carrier = 0; /*XXX*/
|
||||
|
||||
return SIGAR_OK;
|
||||
}
|
||||
|
||||
int sigar_net_connection_list_get(sigar_t *sigar,
|
||||
sigar_net_connection_list_t *connlist,
|
||||
int flags)
|
||||
{
|
||||
return SIGAR_ENOTIMPL;
|
||||
}
|
||||
@@ -0,0 +1,20 @@
|
||||
#ifndef SIGAR_OS_H
|
||||
#define SIGAR_OS_H
|
||||
|
||||
#include <sys/pstat.h>
|
||||
#include <sys/mib.h>
|
||||
#include <stdlib.h>
|
||||
#include <fcntl.h>
|
||||
|
||||
struct sigar_t {
|
||||
SIGAR_T_BASE;
|
||||
struct pst_static pstatic;
|
||||
struct pst_status *proctab;
|
||||
time_t last_getprocs;
|
||||
sigar_pid_t last_pid;
|
||||
struct pst_status *pinfo;
|
||||
};
|
||||
|
||||
int hpux_get_mib_ifentry(int ppa, mib_ifEntry *mib);
|
||||
|
||||
#endif /* SIGAR_OS_H */
|
||||
Reference in new issue
Block a user