/*
* 1. check all the descriptors
*/
void
test_desc(void)
{
int sts;
int i;
pmDesc desc;
print_banner_start("desc");
/* test if possible to get one of them and get its indom */
if ((sts = pmLookupDesc(pmids[0], &desc)) < 0) {
fprintf(stderr, "pmLookupDesc: %s\n", pmErrStr(sts));
fprintf(stderr, "Associated metric = %s (%s)\n", metrics[0], pmIDStr(pmids[0]));
exit(1);
}
indom = desc.indom;
for (i=0; i < nmetrics; i++) {
if ((sts = pmLookupDesc(pmids[i], &desc)) < 0) {
fprintf(stderr, "pmLookupDesc: %s\n", pmErrStr(sts));
fprintf(stderr, "Associated metric = %s (%s)\n", metrics[i], pmIDStr(pmids[i]));
exit(1);
}
if (desc.indom != indom) {
fprintf(stderr, "metric <%s> has indom = %d, different to metric <%s> indom = %d\n",
metrics[i], desc.indom, metrics[0], indom);
fprintf(stderr, "This test requires all metrics have the same indom\n");
exit(1);
}
}
print_banner_end("desc");
}
/* Initialize API and fill in internal description for given Context. */
static void
initapi(Context *x)
{
int e;
x->handle = pmWhichContext();
if ((e = pmLookupName(1, &(x->metric), &(x->pmid))) < 0) {
fprintf(stderr, "%s: pmLookupName(%s): %s\n", pmProgname, x->metric, pmErrStr(e));
exit(EXIT_FAILURE);
}
if ((e = pmLookupDesc(x->pmid, &(x->desc))) < 0) {
fprintf(stderr, "%s: pmLookupDesc: %s\n", pmProgname, pmErrStr(e));
exit(EXIT_FAILURE);
}
if (x->desc.sem == PM_SEM_COUNTER) {
if (x->desc.units.dimTime == 0)
x->scale = 1.0;
else {
if (x->desc.units.scaleTime > PM_TIME_SEC)
x->scale = pow(60, (PM_TIME_SEC - x->desc.units.scaleTime));
else
x->scale = pow(1000, (PM_TIME_SEC - x->desc.units.scaleTime));
}
}
}
static unsigned int
get_ncpu(void)
{
/* there is only one metric in the pmclient_init group */
pmID pmidlist[1];
pmDesc desclist[1];
pmResult *rp;
pmAtomValue atom;
int sts;
if ((sts = pmLookupName(1, pmclient_init, pmidlist)) < 0) {
fprintf(stderr, "%s: pmLookupName: %s\n", pmProgname, pmErrStr(sts));
fprintf(stderr, "%s: metric \"%s\" not in name space\n",
pmProgname, pmclient_init[0]);
exit(1);
}
if ((sts = pmLookupDesc(pmidlist[0], desclist)) < 0) {
fprintf(stderr, "%s: cannot retrieve description for metric \"%s\" (PMID: %s)\nReason: %s\n",
pmProgname, pmclient_init[0], pmIDStr(pmidlist[0]), pmErrStr(sts));
exit(1);
}
if ((sts = pmFetch(1, pmidlist, &rp)) < 0) {
fprintf(stderr, "%s: pmFetch: %s\n", pmProgname, pmErrStr(sts));
exit(1);
}
/* the thing we want is known to be the first value */
pmExtractValue(rp->vset[0]->valfmt, rp->vset[0]->vlist, desclist[0].type,
&atom, PM_TYPE_U32);
pmFreeResult(rp);
return atom.ul;
}
static void
foo(FILE *f, char *fn, int i)
{
pmDesc desc;
char strbuf[60];
int sts;
sts = pmLookupDesc(pmidlist[i], &desc);
if (sts < 0) {
fprintf(f, "%s: pmLookupDesc[%s] -> %s\n", fn, pmIDStr_r(pmidlist[i], strbuf, sizeof(strbuf)), pmErrStr(sts));
pthread_exit("botch");
}
else if (pmidlist[i] != desc.pmid) {
fprintf(f, "%s: pmLookupDesc: Expecting PMID: %s", fn, pmIDStr_r(pmidlist[i], strbuf, sizeof(strbuf)));
fprintf(f, " got: %s\n", pmIDStr_r(desc.pmid, strbuf, sizeof(strbuf)));
pthread_exit("botch");
}
else {
fprintf(f, "%s: %s (%s) ->", fn, namelist[i], pmIDStr_r(pmidlist[i], strbuf, sizeof(strbuf)));
fprintf(f, " %s", pmTypeStr_r(desc.type, strbuf, sizeof(strbuf)));
fprintf(f, " %s", pmInDomStr_r(desc.indom, strbuf, sizeof(strbuf)));
if (desc.sem == PM_SEM_COUNTER) fprintf(f, " counter");
else if (desc.sem == PM_SEM_INSTANT) fprintf(f, " instant");
else if (desc.sem == PM_SEM_DISCRETE) fprintf(f, " discrete");
else fprintf(f, " sem-%d", desc.sem);
fprintf(f, " %s\n", pmUnitsStr_r(&desc.units, strbuf, sizeof(strbuf)));
}
}
static void
myvaluesetdump(pmValueSet *xvsp, int idx, int *flagsp)
{
int sts, flags = *flagsp;
DescHash *hp;
__pmHashNode *hnp;
static __pmHashCtl hash = { 0, 0, NULL };
if ((hnp = __pmHashSearch((unsigned int)xvsp->pmid, &hash)) == NULL) {
/* first time for this pmid */
hp = (DescHash *)malloc(sizeof(DescHash));
if (hp == NULL) {
__pmNoMem("DescHash", sizeof(DescHash), PM_FATAL_ERR);
/*NOTREACHED*/
}
if ((sts = pmNameID(xvsp->pmid, &hp->name)) < 0) {
printf(" %s: pmNameID: %s\n", pmIDStr(xvsp->pmid), pmErrStr(sts));
free(hp);
return;
}
else {
if (xvsp->pmid != pmid_flags &&
xvsp->pmid != pmid_missed &&
(sts = pmLookupDesc(xvsp->pmid, &hp->desc)) < 0) {
printf(" %s: pmLookupDesc: %s\n", hp->name, pmErrStr(sts));
free(hp->name);
free(hp);
return;
}
if ((sts = __pmHashAdd((unsigned int)xvsp->pmid, (void *)hp, &hash)) < 0) {
printf(" %s: __pmHashAdd: %s\n", hp->name, pmErrStr(sts));
free(hp->name);
free(hp);
return;
}
}
}
else
hp = (DescHash *)hnp->data;
if (idx == 0) {
if (xvsp->pmid == pmid_flags) {
flags = *flagsp = xvsp->vlist[0].value.lval;
printf(" flags 0x%x", flags);
printf(" (%s) ---\n", pmEventFlagsStr(flags));
return;
}
else
printf(" ---\n");
}
if ((flags & PM_EVENT_FLAG_MISSED) &&
(idx == 1) &&
(xvsp->pmid == pmid_missed)) {
printf(" ==> %d missed event records\n",
xvsp->vlist[0].value.lval);
return;
}
mydump(hp->name, &hp->desc, xvsp);
}
/* Initialize API and fill in internal description for given Context. */
static void
initapi(Context *x, pmMetricSpec *msp, int argc, char **argv)
{
int e;
x->metric = msp->metric;
if (msp->ninst > 0) {
x->inum = msp->ninst;
x->iall = (x->inum == 0);
x->inames = &msp->inst[0];
}
x->handle = pmWhichContext();
if ((e = pmLookupName(1, &(x->metric), &(x->pmid))) < 0) {
fprintf(stderr, "%s: pmLookupName(%s): %s\n", pmProgname, x->metric,
pmErrStr(e));
exit(EXIT_FAILURE);
}
if ((e = pmLookupDesc(x->pmid, &(x->desc))) < 0) {
fprintf(stderr, "%s: pmLookupDesc: %s\n", pmProgname, pmErrStr(e));
exit(EXIT_FAILURE);
}
if (x->desc.indom == PM_INDOM_NULL && msp->ninst > 0) {
fprintf(stderr, "%s: %s: singular metrics do not have instances\n",
pmProgname, msp->metric);
exit(EXIT_FAILURE);
}
if (x->desc.type == PM_TYPE_EVENT ||
x->desc.type == PM_TYPE_HIGHRES_EVENT) {
amode = PM_MODE_FORW; /* do no interpolate events */
rawArchive = archive;
rawEvents = 1;
}
if (x->desc.sem == PM_SEM_COUNTER) {
if (x->desc.units.dimTime == 0)
x->scale = 1.0;
else {
if (x->desc.units.scaleTime > PM_TIME_SEC)
x->scale = pow(60, (PM_TIME_SEC - x->desc.units.scaleTime));
else
x->scale = pow(1000, (PM_TIME_SEC - x->desc.units.scaleTime));
}
}
}
int
main(int argc, char *argv[])
{
int ctx;
int sts;
char buf[1024];
char *name = buf;
char *p;
pmID pmid;
pmDesc desc;
ctx = pmNewContext(PM_CONTEXT_HOST, "local:");
if (ctx < 0) {
fprintf(stderr, "Error: pmNewContext %s\n", pmErrStr(ctx));
exit(1);
}
printf("/* This file is automatically generated .. do not edit! */\n");
printf("#include \"metrics.h\"\n\n");
printf("metric_t metrics[] = {\n");
while (fgets(buf, sizeof(buf), stdin)) {
if ((p = strrchr(buf, '\n')) != NULL)
*p = '\0';
if ((sts = pmLookupName(1, &name, &pmid)) < 0) {
fprintf(stderr, "Error: pmLookupName \"%s\": %s\n", name, pmErrStr(sts));
exit(1);
}
if ((sts = pmLookupDesc(pmid, &desc)) < 0) {
fprintf(stderr, "Error: pmLookupDesc \"%s\": %s\n", name, pmErrStr(sts));
exit(1);
}
printf(" /* %-8s */ { \"%s\", { 0x%04x, PM_TYPE_%s, %s, %s,\n"
" { .dimSpace=%d, .dimTime=%d, .dimCount=%d, "
".scaleSpace=%d, .scaleTime=%d, .scaleCount=%d } } },\n",
pmIDStr(desc.pmid), name, desc.pmid, pmTypeStr(desc.type),
indomStr(desc.indom), semStr[desc.sem], desc.units.dimSpace,
desc.units.dimTime, desc.units.dimCount, desc.units.scaleSpace,
desc.units.scaleTime, desc.units.scaleCount);
}
printf(" { NULL }\n};\n");
exit(0);
}
void zbx_module_pcp_add_metric(const char *name)
{
int sts;
pmID pmid[1];
pmDesc desc[1];
char *metric;
unsigned flags = 0;
char *param = NULL;
int *instlist;
char **namelist;
ZBX_METRIC *mptr = metrics;
/* PCP preparations. */
sts = pmLookupName(1, (char **)&name, pmid);
if (sts < 0) return;
sts = pmLookupDesc(pmid[0], desc);
if (sts < 0) return;
/* Construct the Zabbix metric name. */
metric = (char *)malloc(strlen(ZBX_PCP_METRIC_PREFIX) + strlen(name) + 1);
if (metric == NULL) return;
strcpy(metric, ZBX_PCP_METRIC_PREFIX);
strcat(metric, name);
/* Pick a PCP metric instance for use with zabbix_agentd -p. */
if (desc[0].indom != PM_INDOM_NULL) {
sts = pmGetInDom(desc[0].indom, &instlist, &namelist);
if (sts < 0) { free(metric); return; }
if (sts) {
flags = CF_HAVEPARAMS;
param = strdup(namelist[0]);
free(instlist);
free(namelist);
}
}
/* Ready for Zabbix. */
metrics = (ZBX_METRIC *)realloc(mptr, (metric_count + 1) * sizeof(ZBX_METRIC));
if (metrics == NULL) { metrics = mptr; free(metric); free(param); return; }
metrics[metric_count].key = metric;
metrics[metric_count].flags = flags;
metrics[metric_count].function = zbx_module_pcp_fetch_metric;
metrics[metric_count].test_param = param;
metric_count++;
}
void
setup_metrics(char **metrics, pmID *pmidlist, pmDesc *desclist, int nmetrics)
{
int i, sts;
if ((sts = pmLookupName(nmetrics, metrics, pmidlist)) < 0)
{
fprintf(stderr, "%s: pmLookupName: %s\n",
pmProgname, pmErrStr(sts));
cleanstop(1);
}
if (nmetrics != sts)
{
for (i=0; i < nmetrics; i++)
{
if (pmidlist[i] != PM_ID_NULL)
continue;
if (pmDebug & DBG_TRACE_APPL0)
fprintf(stderr,
"%s: pmLookupName failed for %s\n",
pmProgname, metrics[i]);
}
}
for (i=0; i < nmetrics; i++)
{
if (pmidlist[i] == PM_ID_NULL)
{
desclist[i].pmid = PM_ID_NULL;
continue;
}
if ((sts = pmLookupDesc(pmidlist[i], &desclist[i])) < 0)
{
if (pmDebug & DBG_TRACE_APPL0)
fprintf(stderr,
"%s: pmLookupDesc failed for %s: %s\n",
pmProgname, metrics[i], pmErrStr(sts));
pmidlist[i] = desclist[i].pmid = PM_ID_NULL;
}
}
}
static void
dump_parameter(pmValueSet *xvsp, int index, int *flagsp)
{
int sts, flags = *flagsp;
pmDesc desc;
char **names;
if ((sts = pmNameAll(xvsp->pmid, &names)) >= 0) {
if (index == 0) {
if (xvsp->pmid == pmid_flags) {
flags = *flagsp = xvsp->vlist[0].value.lval;
printf(" flags 0x%x", flags);
printf(" (%s) ---\n", pmEventFlagsStr(flags));
free(names);
return;
}
printf(" ---\n");
}
if ((flags & PM_EVENT_FLAG_MISSED) && index == 1 &&
(xvsp->pmid == pmid_missed)) {
printf(" ==> %d missed event records\n",
xvsp->vlist[0].value.lval);
free(names);
return;
}
printf(" %s (", pmIDStr(xvsp->pmid));
__pmPrintMetricNames(stdout, sts, names, " or ");
printf("):");
free(names);
}
else
printf(" PMID: %s:", pmIDStr(xvsp->pmid));
if ((sts = pmLookupDesc(xvsp->pmid, &desc)) < 0) {
printf(" pmLookupDesc: %s\n", pmErrStr(sts));
return;
}
printf(" value ");
pmPrintValue(stdout, xvsp->valfmt, desc.type, &xvsp->vlist[0], 1);
putchar('\n');
}
/* initialize Metric */
int /* 1: ok, 0: try again later, -1: fail */
initMetric(Metric *m)
{
char *hname = symName(m->hname);
char *mname = symName(m->mname);
char **inames;
int *iids;
int handle;
int ret = 1;
int sts;
int i, j;
/* set up temporary context */
if ((handle = newContext(hname)) < 0)
return 0;
host_state_changed(hname, STATE_RECONN);
if ((sts = pmLookupName(1, &mname, &m->desc.pmid)) < 0) {
fprintf(stderr, "%s: metric %s not in namespace for %s\n"
"pmLookupName failed: %s\n",
pmProgname, mname, findsource(hname), pmErrStr(sts));
ret = 0;
goto end;
}
/* fill in performance metric descriptor */
if ((sts = pmLookupDesc(m->desc.pmid, &m->desc)) < 0) {
fprintf(stderr, "%s: metric %s not currently available from %s\n"
"pmLookupDesc failed: %s\n",
pmProgname, mname, findsource(hname), pmErrStr(sts));
ret = 0;
goto end;
}
if (m->desc.type == PM_TYPE_STRING ||
m->desc.type == PM_TYPE_AGGREGATE ||
m->desc.type == PM_TYPE_AGGREGATE_STATIC ||
m->desc.type == PM_TYPE_EVENT ||
m->desc.type == PM_TYPE_HIGHRES_EVENT ||
m->desc.type == PM_TYPE_UNKNOWN) {
fprintf(stderr, "%s: metric %s has non-numeric type\n", pmProgname, mname);
ret = -1;
}
else if (m->desc.indom == PM_INDOM_NULL) {
if (m->specinst != 0) {
fprintf(stderr, "%s: metric %s has no instances\n", pmProgname, mname);
ret = -1;
}
else
m->m_idom = 1;
}
else {
/* metric has instances, get full instance profile */
if (archives) {
if ((sts = pmGetInDomArchive(m->desc.indom, &iids, &inames)) < 0) {
fprintf(stderr, "Metric %s from %s - instance domain not "
"available in archive\npmGetInDomArchive failed: %s\n",
mname, findsource(hname), pmErrStr(sts));
ret = -1;
}
}
else if ((sts = pmGetInDom(m->desc.indom, &iids, &inames)) < 0) {
fprintf(stderr, "Instance domain for metric %s from %s not (currently) available\n"
"pmGetIndom failed: %s\n", mname, findsource(hname), pmErrStr(sts));
ret = 0;
}
if (ret == 1) { /* got instance profile */
if (m->specinst == 0) {
/* all instances */
m->iids = iids;
m->m_idom = sts;
m->inames = alloc(m->m_idom*sizeof(char *));
for (i = 0; i < m->m_idom; i++) {
m->inames[i] = sdup(inames[i]);
}
}
else {
/* selected instances only */
m->m_idom = 0;
for (i = 0; i < m->specinst; i++) {
/* look for first matching instance name */
for (j = 0; j < sts; j++) {
if (eqinst(m->inames[i], inames[j])) {
m->iids[i] = iids[j];
m->m_idom++;
break;
}
}
if (j == sts) {
__pmNotifyErr(LOG_ERR, "metric %s from %s does not "
"(currently) have instance \"%s\"\n",
mname, findsource(hname), m->inames[i]);
m->iids[i] = PM_IN_NULL;
ret = 0;
}
}
if (sts > 0) {
/*
* pmGetInDom or pmGetInDomArchive returned some
* instances above
*/
free(iids);
}
/*
* if specinst != m_idom, then some not found ... move these
* to the end of the list
*/
for (j = m->specinst-1; j >= 0; j--) {
if (m->iids[j] != PM_IN_NULL)
break;
}
for (i = 0; i < j; i++) {
if (m->iids[i] == PM_IN_NULL) {
/* need to swap */
char *tp;
tp = m->inames[i];
m->inames[i] = m->inames[j];
m->iids[i] = m->iids[j];
m->inames[j] = tp;
m->iids[j] = PM_IN_NULL;
j--;
}
}
}
#if PCP_DEBUG
if (pmDebug & DBG_TRACE_APPL1) {
int numinst;
fprintf(stderr, "initMetric: %s from %s: instance domain specinst=%d\n",
mname, hname, m->specinst);
if (m->m_idom < 1) fprintf(stderr, " %d instances!\n", m->m_idom);
numinst = m->specinst == 0 ? m->m_idom : m->specinst;
for (i = 0; i < numinst; i++) {
fprintf(stderr, " indom[%d]", i);
if (m->iids[i] == PM_IN_NULL)
fprintf(stderr, " ?missing");
else
fprintf(stderr, " %d", m->iids[i]);
fprintf(stderr, " \"%s\"\n", m->inames[i]);
}
}
#endif
if (sts > 0) {
/*
* pmGetInDom or pmGetInDomArchive returned some instances
* above
*/
free(inames);
}
}
}
if (ret == 1) {
/* compute conversion factor into canonical units
- non-zero conversion factor flags initialized metric */
m->conv = scale(m->desc.units);
/* automatic rate computation */
if (m->desc.sem == PM_SEM_COUNTER) {
m->vals = (double *) ralloc(m->vals, m->m_idom * sizeof(double));
for (j = 0; j < m->m_idom; j++)
m->vals[j] = 0;
}
}
end:
/* destroy temporary context */
pmDestroyContext(handle);
/* retry not meaningful for archives */
if (archives && (ret == 0))
ret = -1;
return ret;
}
static void
func(void)
{
int sts;
char **children;
char *p;
if ((sts = pmUseContext(ctx)) < 0) {
printf("pmUseContext(%d): %s\n", ctx, pmErrStr(sts));
pthread_exit(NULL);
}
/*
* expect this to fail for the second thread through when
* using PM_CONTEXT_LOCAL
*/
if ((sts = pmDupContext()) < 0)
printf("pmDupContext: %s\n", pmErrStr(sts));
else
printf("pmDupContext: -> %d\n", sts);
if ((sts = pmUseContext(ctx)) < 0) {
printf("pmUseContext(%d): %s\n", ctx, pmErrStr(sts));
pthread_exit(NULL);
}
else
printf("pmUseContext(%d) -> %d\n", ctx, sts);
if ((sts = pmLookupName(1, namelist, pmidlist)) < 0)
printf("pmLookupName: %s\n", pmErrStr(sts));
else
printf("pmLookupName: -> %s\n", pmIDStr(pmidlist[0]));
pthread_barrier_wait(&barrier);
if (pmidlist[0] == 0)
pthread_exit("Loser failed to get pmid!");
if ((sts = pmGetPMNSLocation()) < 0)
printf("pmGetPMNSLocation: %s\n", pmErrStr(sts));
else
printf("pmGetPMNSLocation: -> %d\n", sts);
/* leaf node, expect no children */
if ((sts = pmGetChildrenStatus(namelist[0], &children, NULL)) < 0)
printf("pmGetChildrenStatus: %s\n", pmErrStr(sts));
else
printf("pmGetChildrenStatus: -> %d\n", sts);
if ((sts = pmLookupDesc(pmidlist[0], &desc)) < 0)
printf("pmLookupDesc: %s\n", pmErrStr(sts));
else
printf("pmLookupDesc: -> %s type=%s indom=%s\n", pmIDStr(desc.pmid), pmTypeStr(desc.type), pmInDomStr(desc.indom));
pthread_barrier_wait(&barrier);
if (desc.pmid == 0)
pthread_exit("Loser failed to get pmDesc!");
if ((sts = pmLookupText(pmidlist[0], PM_TEXT_ONELINE, &p)) < 0)
printf("pmLookupText: %s\n", pmErrStr(sts));
else
printf("pmLookupText: -> %s\n", p);
if ((sts = pmGetInDom(desc.indom, &instance, &instname)) < 0)
printf("pmGetInDom: %s: %s\n", pmInDomStr(desc.indom), pmErrStr(sts));
else
printf("pmGetInDom: -> %d\n", sts);
pthread_barrier_wait(&barrier);
if (instance == NULL)
pthread_exit("Loser failed to get indom!");
if ((sts = pmNameInDom(desc.indom, instance[0], &p)) < 0)
printf("pmNameInDom: %s\n", pmErrStr(sts));
else
printf("pmNameInDom: %d -> %s\n", instance[0], p);
if ((sts = pmLookupInDom(desc.indom, instname[0])) < 0)
printf("pmLookupInDom: %s\n", pmErrStr(sts));
else
printf("pmLookupInDom: %s -> %d\n", instname[0], sts);
if ((sts = pmFetch(1, pmidlist, &rp)) < 0)
printf("pmFetch: %s\n", pmErrStr(sts));
else
printf("pmFetch: -> OK\n");
pthread_barrier_wait(&barrier);
if (rp == NULL)
pthread_exit("Loser failed to get pmResult!");
if ((sts = pmStore(rp)) < 0)
printf("pmStore: %s\n", pmErrStr(sts));
else
printf("pmStore: -> OK\n");
pthread_exit(NULL);
}
int zbx_module_pcp_fetch_metric(AGENT_REQUEST *request, AGENT_RESULT *result)
{
int sts;
char *metric[] = { request->key + strlen(ZBX_PCP_METRIC_PREFIX) };
char *inst;
pmID pmid[1];
pmDesc desc[1];
pmResult *rp;
pmAtomValue atom;
int iid = 0;
int i;
/* Parameter is the instance. */
switch(request->nparam) {
case 0:
inst = NULL;
break;
case 1:
inst = get_rparam(request, 0);
break;
default:
SET_MSG_RESULT(result, strdup("Extraneous instance specification."));
return SYSINFO_RET_FAIL;
break;
}
/* Preparations and sanity checks. */
sts = pmLookupName(1, metric, pmid);
if (sts < 0) return SYSINFO_RET_FAIL;
sts = pmLookupDesc(pmid[0], desc);
if (sts < 0) return SYSINFO_RET_FAIL;
if (inst != NULL && desc[0].indom == PM_INDOM_NULL) {
SET_MSG_RESULT(result, strdup("Extraneous instance specification."));
return SYSINFO_RET_FAIL;
}
if ((inst == NULL && desc[0].indom != PM_INDOM_NULL) ||
(request->nparam == 1 && !strlen(inst))) {
SET_MSG_RESULT(result, strdup("Missing instance specification."));
return SYSINFO_RET_FAIL;
}
if (desc[0].indom != PM_INDOM_NULL) {
iid = pmLookupInDom(desc[0].indom, inst);
if (iid < 0) {
SET_MSG_RESULT(result, strdup("Instance not available."));
return SYSINFO_RET_FAIL;
}
}
/* Fetch the metric values. */
sts = pmFetch(1, pmid, &rp);
if (sts < 0) return SYSINFO_RET_FAIL;
if (rp->vset[0]->numval < 1) {
pmFreeResult(rp);
SET_MSG_RESULT(result, strdup("No value available."));
return SYSINFO_RET_FAIL;
}
/* Locate the correct instance. */
for (i = 0; desc[0].indom != PM_INDOM_NULL && i < rp->vset[0]->numval; i++) {
if (rp->vset[0]->vlist[i].inst == iid) {
break;
}
}
if (i == rp->vset[0]->numval) {
pmFreeResult(rp);
return SYSINFO_RET_FAIL;
}
/* Extract the wanted value. */
sts = pmExtractValue(rp->vset[0]->valfmt, &rp->vset[0]->vlist[i],
desc[0].type, &atom, desc[0].type);
pmFreeResult(rp);
if (sts < 0) return SYSINFO_RET_FAIL;
/* Hand it to the caller. */
switch(desc[0].type) {
case PM_TYPE_32:
SET_UI64_RESULT(result, atom.l);
break;
case PM_TYPE_U32:
SET_UI64_RESULT(result, atom.ul);
break;
case PM_TYPE_64:
SET_UI64_RESULT(result, atom.ll);
break;
case PM_TYPE_U64:
SET_UI64_RESULT(result, atom.ull);
break;
case PM_TYPE_FLOAT:
SET_DBL_RESULT(result, atom.f);
break;
case PM_TYPE_DOUBLE:
SET_DBL_RESULT(result, atom.d);
break;
case PM_TYPE_STRING:
SET_STR_RESULT(result, strdup(atom.cp));
break;
default:
SET_MSG_RESULT(result, strdup("Unsupported metric value type."));
return SYSINFO_RET_FAIL;
break;
}
/* Success. */
return SYSINFO_RET_OK;
}
static void
docheck(pmResult *result)
{
int i, j, k;
int sts;
pmDesc desc;
pmAtomValue av;
pmValue *vp;
pmValueSet *vsp;
__pmHashNode *hptr = NULL;
checkData *checkdata = NULL;
double diff;
struct timeval timediff;
for (i = 0; i < result->numpmid; i++) {
vsp = result->vset[i];
#ifdef PCP_DEBUG
if (pmDebug & DBG_TRACE_APPL1) {
if (vsp->numval == 0) {
fprintf(stderr, "%s.%d:[", l_archname, l_ctxp->c_archctl->ac_vol);
print_stamp(stderr, &result->timestamp);
fprintf(stderr, "] ");
print_metric(stderr, vsp->pmid);
fprintf(stderr, ": no values returned\n");
continue;
}
else if (vsp->numval < 0) {
fprintf(stderr, "%s.%d:[", l_archname, l_ctxp->c_archctl->ac_vol);
print_stamp(stderr, &result->timestamp);
fprintf(stderr, "] ");
print_metric(stderr, vsp->pmid);
fprintf(stderr, ": error from numval: %s\n", pmErrStr(vsp->numval));
continue;
}
}
#endif
if (vsp->numval <= 0)
continue;
/* check if pmid already in hash list */
if ((hptr = __pmHashSearch(vsp->pmid, &hashlist)) == NULL) {
if ((sts = pmLookupDesc(vsp->pmid, &desc)) < 0) {
fprintf(stderr, "%s.%d:[", l_archname, l_ctxp->c_archctl->ac_vol);
print_stamp(stderr, &result->timestamp);
fprintf(stderr, "] ");
print_metric(stderr, vsp->pmid);
fprintf(stderr, ": pmLookupDesc failed: %s\n", pmErrStr(sts));
continue;
}
if (desc.type != PM_TYPE_32 && desc.type != PM_TYPE_U32 &&
desc.type != PM_TYPE_64 && desc.type != PM_TYPE_U64 &&
desc.type != PM_TYPE_FLOAT && desc.type != PM_TYPE_DOUBLE) {
continue; /* no checks for non-numeric metrics */
}
/* create a new one & add to list */
checkdata = (checkData*) malloc(sizeof(checkData));
newHashItem(vsp, &desc, checkdata, &result->timestamp);
if (__pmHashAdd(checkdata->desc.pmid, (void*)checkdata, &hashlist) < 0) {
fprintf(stderr, "%s.%d:[", l_archname, l_ctxp->c_archctl->ac_vol);
print_stamp(stderr, &result->timestamp);
fprintf(stderr, "] ");
print_metric(stderr, vsp->pmid);
fprintf(stderr, ": __pmHashAdd failed (internal pmlogcheck error)\n");
/* free memory allocated above on insert failure */
for (j = 0; j < vsp->numval; j++) {
if (checkdata->instlist[j] != NULL)
free(checkdata->instlist[j]);
}
if (checkdata->instlist != NULL)
free(checkdata->instlist);
continue;
}
}
else { /* pmid exists - update statistics */
checkdata = (checkData *)hptr->data;
for (j = 0; j < vsp->numval; j++) { /* iterate thro result values */
vp = &vsp->vlist[j];
k = j; /* index into stored inst list, result may differ */
if ((vsp->numval > 1) || (checkdata->desc.indom != PM_INDOM_NULL)) {
/* must store values using correct inst - probably in correct order already */
if ((k < checkdata->listsize) && (checkdata->instlist[k]->inst != vp->inst)) {
for (k = 0; k < checkdata->listsize; k++) {
if (vp->inst == checkdata->instlist[k]->inst) {
break; /* k now correct */
}
}
if (k == checkdata->listsize) { /* no matching inst was found */
newHashInst(vp, checkdata, vsp->valfmt, &result->timestamp, k);
continue;
}
}
else if (k >= checkdata->listsize) {
k = checkdata->listsize;
newHashInst(vp, checkdata, vsp->valfmt, &result->timestamp, k);
continue;
}
}
if (k >= checkdata->listsize) { /* only error values observed so far */
k = checkdata->listsize;
newHashInst(vp, checkdata, vsp->valfmt, &result->timestamp, k);
continue;
}
timediff = result->timestamp;
tsub(&timediff, &(checkdata->instlist[k]->lasttime));
if (timediff.tv_sec < 0) {
/* clip negative values at zero */
timediff.tv_sec = 0;
timediff.tv_usec = 0;
}
diff = __pmtimevalToReal(&timediff);
if ((sts = pmExtractValue(vsp->valfmt, vp, checkdata->desc.type, &av, PM_TYPE_DOUBLE)) < 0) {
fprintf(stderr, "%s.%d:[", l_archname, l_ctxp->c_archctl->ac_vol);
print_stamp(stderr, &result->timestamp);
fprintf(stderr, "] ");
print_metric(stderr, vsp->pmid);
fprintf(stderr, ": pmExtractValue failed: %s\n", pmErrStr(sts));
continue;
}
if (checkdata->desc.sem == PM_SEM_COUNTER) {
if (diff == 0.0) continue;
diff *= checkdata->scale;
#ifdef PCP_DEBUG
if (pmDebug & DBG_TRACE_APPL2) {
fprintf(stderr, "%s.%d:[", l_archname, l_ctxp->c_archctl->ac_vol);
print_stamp(stderr, &result->timestamp);
fprintf(stderr, "] ");
print_metric(stderr, checkdata->desc.pmid);
fprintf(stderr, ": current counter value is %.0f\n", av.d);
}
#endif
unwrap(av.d, &(result->timestamp), checkdata, k);
}
checkdata->instlist[k]->lastval = av.d;
checkdata->instlist[k]->lasttime = result->timestamp;
}
}
}
}
/*
* Called when an error PDU containing PMCD_ADD_AGENT is received.
* This function checks all of the configured metrics to make sure that
* they have not changed. For example due to a PMDA being replaced by an
* updated version
*/
void
validate_metrics(void)
{
const task_t *tp;
pmID *new_pmids;
const pmDesc *old_desc;
pmDesc new_desc;
int index;
int error;
int sts;
time_t now;
char buf1[20], buf2[20];
time(&now);
fprintf(stderr, "%s: Validating metrics after PMCD state changed at %s",
pmProgname, ctime(&now));
/*
* Check each metric in each element of the task list, whether it is
* active or not.
*/
error = 0;
for (tp = tasklist; tp != NULL; tp = tp->t_next) {
/* We need at least one metric to look up. */
if (tp->t_numpmid < 1)
continue;
/*
* Perform a bulk lookup and then check for consistency.
* Lookup the metrics by name, since that's the way they are
* specified in the pmlogger config file.
* We need a temporary array for the new pmIDs
*/
new_pmids = malloc(tp->t_numpmid * sizeof(*tp->t_pmidlist));
if (new_pmids == NULL) {
__pmNoMem("allocating pmID array for validating metrice",
tp->t_numpmid * sizeof(*tp->t_pmidlist), PM_FATAL_ERR);
}
if ((sts = pmLookupName(tp->t_numpmid, tp->t_namelist, new_pmids)) < 0) {
fprintf(stderr, "Error looking up metrics: Reason: %s\n",
pmErrStr(sts));
exit(1);
}
/* Now check the individual metrics for problems. */
for (index = 0; index < tp->t_numpmid; ++index) {
/* If there was an error looking up this metric, try again in order
* to obtain the reason. If there is no error the second time
* (possible), then the needed pmID will be fetched.
*/
if (new_pmids[index] == PM_ID_NULL) {
if ((sts = pmLookupName(1, &tp->t_namelist[index],
&new_pmids[index])) < 0) {
/* The lookup of the metric is still in error. */
fprintf(stderr, "Error looking up %s: Reason: %s\n",
tp->t_namelist[index], pmErrStr(sts));
++error;
continue;
}
/* No error the second time. Fall through */
}
/*
* Check that the pmid, type, semantics, instance domain and units
* of the metric have not changed.
*/
if (new_pmids[index] != tp->t_pmidlist[index]) {
fprintf(stderr, "PMID of metric \"%s\" has changed from %s to %s\n",
tp->t_namelist[index],
pmIDStr_r(tp->t_pmidlist[index], buf1, sizeof(buf1)),
pmIDStr_r(new_pmids[index], buf2, sizeof(buf2)));
++error;
}
if ((sts = pmLookupDesc(new_pmids[index], &new_desc)) < 0) {
fprintf(stderr, "Description unavailable for metric \"%s\": %s\n",
tp->t_namelist[index], pmErrStr(sts));
++error;
continue;
}
old_desc = &tp->t_desclist[index];
if (new_desc.type != old_desc->type) {
fprintf(stderr, "Type of metric \"%s\" has changed from %s to %s\n",
tp->t_namelist[index],
pmTypeStr_r(old_desc->type, buf1, sizeof(buf1)),
pmTypeStr_r(new_desc.type, buf2, sizeof(buf2)));
++error;
}
if (new_desc.sem != old_desc->sem) {
fprintf(stderr, "Semantics of metric \"%s\" have changed from %s to %s\n",
tp->t_namelist[index],
pmSemStr_r(old_desc->sem, buf1, sizeof(buf1)),
pmSemStr_r(new_desc.sem, buf2, sizeof(buf2)));
++error;
}
if (new_desc.indom != old_desc->indom) {
fprintf(stderr, "Instance domain of metric \"%s\" has changed from %s to %s\n",
tp->t_namelist[index],
pmInDomStr_r(old_desc->indom, buf1, sizeof(buf1)),
pmInDomStr_r(new_desc.indom, buf2, sizeof(buf2)));
++error;
}
if (new_desc.units.dimSpace != old_desc->units.dimSpace ||
new_desc.units.dimTime != old_desc->units.dimTime ||
new_desc.units.dimCount != old_desc->units.dimCount ||
new_desc.units.scaleSpace != old_desc->units.scaleSpace ||
new_desc.units.scaleTime != old_desc->units.scaleTime ||
new_desc.units.scaleCount != old_desc->units.scaleCount) {
++error;
fprintf(stderr, "Units of metric \"%s\" has changed from %s to %s\n",
tp->t_namelist[index],
pmUnitsStr_r(&old_desc->units, buf1, sizeof(buf1)),
pmUnitsStr_r(&new_desc.units, buf2, sizeof(buf2)));
}
} /* loop over metrics */
free(new_pmids);
} /* Loop over task list */
/* We cannot continue, if any of the metrics have changed. */
if (error) {
fprintf(stderr, "One or more configured metrics have changed after pmcd state change. Exiting\n");
exit(1);
}
}
/* Return (in result) a list of active pmlogger ports on the specified machine.
* The return value of the function is the number of elements in the array.
* The caller must NOT free any part of the result stucture, it's storage is
* managed here. Subsequent calls will overwrite the data so the caller should
* copy it if persistence is required.
*/
int
__pmLogFindPort(const char *host, int pid, __pmLogPort **lpp)
{
int ctx, oldctx;
char *ctxhost;
int sts, numval;
int i, j;
int findone = pid != PM_LOG_ALL_PIDS;
int localcon = 0; /* > 0 for local connection */
pmDesc desc;
pmResult *res;
char *namelist[] = {"pmcd.pmlogger.port"};
pmID pmid;
if (PM_MULTIPLE_THREADS(PM_SCOPE_LOGPORT))
return PM_ERR_THREAD;
*lpp = NULL; /* pass null back in event of error */
localcon = __pmIsLocalhost(host);
if (localcon > 0)
/* do the work here instead of making PMCD do it */
return __pmLogFindLocalPorts(pid, lpp);
else if (localcon < 0)
return localcon;
/* note: there may not be a current context */
ctx = 0;
oldctx = pmWhichContext();
/*
* Enclose ctxhost in [] in case it is an ipv6 address. This prevents
* the first colon from being taken as a port separator by pmNewContext
* and does no harm otherwise.
*/
ctxhost = malloc(strlen(host) + 2 + 1);
if (ctxhost == NULL) {
sts = -ENOMEM;
goto ctxErr;
}
sprintf(ctxhost, "[%s]", host);
ctx = pmNewContext(PM_CONTEXT_HOST, ctxhost);
free(ctxhost);
if (ctx < 0)
return ctx;
if ((sts = pmLookupName(1, namelist, &pmid)) < 0)
goto ctxErr;
if ((sts = pmLookupDesc(pmid, &desc)) < 0)
goto ctxErr;
if ((sts = pmFetch(1, &pmid, &res) < 0))
goto ctxErr;
if ((sts = numval = res->vset[0]->numval) < 0)
goto resErr;
j = 0;
if (numval) {
if (resize_logports(findone ? 1 : numval) < 0) {
sts = -oserror();
goto resErr;
}
/* scan the pmResult, copying matching pid(s) to logport */
for (i = j = 0; i < numval; i++) {
__pmLogPort *p = &logport[j];
pmValue *vp = &res->vset[0]->vlist[i];
if (vp->inst == 1) /* old vcr instance (pseudo-init) */
continue;
if (findone && vp->inst != pid)
continue;
p->pid = vp->inst;
p->port = vp->value.lval;
sts = pmNameInDom(desc.indom, p->pid, &p->name);
if (sts < 0) {
p->name = NULL;
goto resErr;
}
j++;
if (findone) /* found one, stop searching */
break;
}
*lpp = logport;
}
sts = j; /* the number actually added */
resErr:
pmFreeResult(res);
ctxErr:
if (oldctx >= 0)
pmUseContext(oldctx);
if (ctx >= 0)
pmDestroyContext(ctx);
return sts;
}
/* create a pmValueSet large enough to contain the union of the current
* instance domain of the specified metric and any previous instances from
* the history list.
*/
static pmValueSet *
build_vset(pmID pmid, int usehist)
{
__pmHashNode *hp;
pmidhist_t *php = NULL;
insthist_t *ihp;
int need = 0;
int i, numindom = 0;
pmDesc desc;
int have_desc;
int *instlist = NULL;
char **namelist = NULL;
pmValueSet *vsp;
if (usehist) {
/* find the number of instances of the metric in the history (1 if
* single-valued metric)
*/
for (hp = __pmHashSearch(pmid, &hist_hash); hp != NULL; hp = hp->next)
if ((pmID)hp->key == pmid)
break;
if (hp != NULL) {
php = (pmidhist_t *)hp->data;
need = php->ph_numinst;
}
}
/*
* get the current instance domain, so that if the metric hasn't been
* logged yet a sensible result is returned.
*/
if ((have_desc = pmLookupDesc(pmid, &desc)) < 0)
goto no_info;
if (desc.indom == PM_INDOM_NULL)
need = 1; /* will be same in history */
else {
int j;
if ((numindom = pmGetInDom(desc.indom, &instlist, &namelist)) < 0) {
have_desc = numindom;
goto no_info;
}
/* php will be null if usehist is false or there is no history yet */
if (php == NULL)
need = numindom; /* no history => use indom */
else
for (i = 0; i < numindom; i++) {
int inst = instlist[i];
for (j = 0; j < php->ph_numinst; j++)
if (inst == php->ph_instlist[j].ih_inst)
break;
/*
* if instance is in history but not instance domain, leave
* extra space for it in vset, otherwise use the USEINDOM
* flag to avoid another NxM comparison when building the vset
* instances later.
*/
if (j >= php->ph_numinst)
need++;
else
PMLC_SET_USEINDOM(php->ph_instlist[j].ih_flags, 1);
}
}
no_info:
need = sizeof(pmValueSet) + (need - 1) * sizeof(pmValue);
vsp = (pmValueSet *)malloc(need);
if (vsp == NULL) {
__pmNoMem("build_vset for control/enquire", need, PM_FATAL_ERR);
}
vsp->pmid = pmid;
if (have_desc < 0) {
vsp->numval = have_desc;
}
else if (desc.indom == PM_INDOM_NULL) {
vsp->vlist[0].inst = PM_IN_NULL;
vsp->numval = 1;
}
else {
int j;
i = 0;
/* get instances out of instance domain first */
if (numindom > 0)
for (j = 0; j < numindom; j++)
vsp->vlist[i++].inst = instlist[j];
/* then any not in instance domain from history */
if (php != NULL) {
ihp = &php->ph_instlist[0];
for (j = 0; j < php->ph_numinst; j++, ihp++)
if (PMLC_GET_USEINDOM(ihp->ih_flags))
/* it's already in the indom */
PMLC_SET_USEINDOM(ihp->ih_flags, 0);
else
vsp->vlist[i++].inst = ihp->ih_inst;
}
vsp->numval = i;
}
if (instlist)
free(instlist);
if (namelist)
free(namelist);
return vsp;
}
/* Update an existing metric (given a pmValueSet) adding it to the specified
* task. Allocate and return a new task_t if the specified task pointer is nil.
*/
static int
update_metric(pmValueSet *vsp, int reqstate, int mflags, task_t **result)
{
pmID pmid = vsp->pmid;
task_t *ntp = *result; /* pointer to new task */
task_t *ctp; /* pointer to current task */
optreq_t *rqp;
pmDesc *dp;
int i, j, inst;
int sts, need = 0;
int addpmid = 0;
int freedp;
/* allocate a new task if null task pointer passed in */
if (ntp == NULL) {
ntp = calloc(1, sizeof(task_t));
if (ntp == NULL) {
__pmNoMem("update_metric: new task calloc", sizeof(task_t),
PM_FATAL_ERR);
}
*result = ntp;
}
if ((mflags & MF_HAS_INDOM) == 0) {
rqp = findoptreq(pmid, 0);
ctp = (task_t *)(rqp->r_fetch->f_aux);
if (!update_ok(ctp->t_state, reqstate))
return 1;
/* if the new state is advisory off, just remove the metric */
if ((PMLC_GET_MAYBE(reqstate)) ||
(PMLC_GET_MAND(reqstate) == 0 && PMLC_GET_ON(reqstate) == 0))
del_optreq(rqp);
else {
/* update the optreq. For single valued metrics there are no
* instances involved so the sole optreq can just be re-used.
*/
if ((sts = __pmOptFetchDel(&ctp->t_fetch, rqp)) < 0)
die("update_metric: 1 metric __pmOptFetchDel", sts);
__pmOptFetchAdd(&ntp->t_fetch, rqp);
linkback(ntp);
addpmid = 1;
}
}
else {
/* metric has an instance domain */
if (vsp->numval > 0) {
/* tricky: since optFetch can't handle instance profiles of the
* form "all except these specific instances", and managing it
* manually is just too hard, reject requests for specific
* metric instances if "all instances" of the metric are already
* being logged.
* Note: advisory off "all instances" is excepted since ANY request
* overrides and advisory off. E.g. "advisory off all" followed by
* "advisory on someinsts" turns on advisory logging for
* "someinsts". mflags will be zero for "advisory off" metrics.
*/
if (mflags & MF_HAS_ALL)
return 1; /* can't turn "all" into specific insts */
for (i = 0; i < vsp->numval; i++) {
dp = NULL;
freedp = 0;
inst = vsp->vlist[i].inst;
rqp = findoptreq(pmid, inst);
if (rqp != NULL) {
dp = rqp->r_desc;
ctp = (task_t *)(rqp->r_fetch->f_aux);
/* no work required if new task and current are the same */
if (ntp == ctp)
continue;
if (!update_ok(ctp->t_state, reqstate))
continue;
/* remove inst's group from current task */
if ((sts = __pmOptFetchDel(&ctp->t_fetch, rqp)) < 0)
die("update_metric: instance add __pmOptFetchDel", sts);
/* put group back if there are any instances left */
if (rqp->r_numinst > 1) {
/* remove inst from group */
for (j = 0; j < rqp->r_numinst; j++)
if (inst == rqp->r_instlist[j])
break;
/* don't call memmove to move zero bytes */
if (j < rqp->r_numinst - 1)
memmove(&rqp->r_instlist[j], &rqp->r_instlist[j+1],
(rqp->r_numinst - 1 - j) *
sizeof(rqp->r_instlist[0]));
rqp->r_numinst--;
/* (don't bother realloc-ing the instlist to a smaller size) */
__pmOptFetchAdd(&ctp->t_fetch, rqp);
linkback(ctp);
/* no need to update hash list, rqp already there */
}
/* if that was the last instance, free the group */
else {
if (( sts = __pmHashDel(pmid, (void *)rqp, &pm_hash)) < 0)
die("update_metric: instance __pmHashDel", sts);
freedp = 1;
free(rqp->r_instlist);
free(rqp);
}
}
/* advisory off (mandatory maybe) metrics don't get put into
* the data structure
*/
if (PMLC_GET_MAYBE(reqstate) ||
(PMLC_GET_MAND(reqstate) == 0 && PMLC_GET_ON(reqstate) == 0)) {
if (freedp)
free(dp);
continue;
}
addpmid = 1;
/* try to find an existing optreq_t for the instance */
rqp = find_instoptreq(ntp, pmid);
if (rqp != NULL) {
if ((sts = __pmOptFetchDel(&ntp->t_fetch, rqp)) < 0)
die("update_metric: instance add __pmOptFetchDel", sts);
}
/* no existing optreq_t found, allocate & populate a new one */
else {
rqp = (optreq_t *)calloc(1, sizeof(optreq_t));
if (rqp == NULL) {
__pmNoMem("update_metric: optreq calloc",
sizeof(optreq_t), PM_FATAL_ERR);
}
/* if the metric existed but the instance didn't, we don't
* have a valid pmDesc (dp), so find one.
*/
if (dp == NULL) {
/* find metric and associated pmDesc */
__pmHashNode *hp;
for (hp = __pmHashSearch(pmid, &pm_hash);
hp != NULL; hp = hp->next) {
if (pmid == (pmID)hp->key)
break;
}
assert(hp != NULL);
dp = ((optreq_t *)hp->data)->r_desc;
}
/* recycle pmDesc from the old group, if possible */
if (freedp) {
rqp->r_desc = dp;
freedp = 0;
}
/* otherwise allocate & copy a new pmDesc via dp */
else {
need = sizeof(pmDesc);
rqp->r_desc = (pmDesc *)malloc(need);
if (rqp->r_desc == NULL) {
__pmNoMem("update_metric: new inst pmDesc malloc",
need, PM_FATAL_ERR);
}
memcpy(rqp->r_desc, dp, need);
}
if ((sts = __pmHashAdd(pmid, (void *)rqp, &pm_hash)) < 0)
die("update_metric: __pmHashAdd", sts);
}
need = (rqp->r_numinst + 1) * sizeof(rqp->r_instlist[0]);
rqp->r_instlist = (int *)realloc(rqp->r_instlist, need);
if (rqp->r_instlist == NULL) {
__pmNoMem("update_metric: inst list resize", need,
PM_FATAL_ERR);
}
rqp->r_instlist[rqp->r_numinst++] = inst;
__pmOptFetchAdd(&ntp->t_fetch, rqp);
linkback(ntp);
if (freedp)
free(dp);
}
}
/* the vset has numval == 0, a request for "all instances" */
else {
/* if the metric is a singular instance that has mandatory logging
* or has at least one instance with mandatory logging on, a
* request for advisory logging cannot be honoured
*/
if ((mflags & MF_HAS_MAND) &&
PMLC_GET_MAND(reqstate) == 0 && PMLC_GET_MAYBE(reqstate) == 0)
return 1;
if (mflags & MF_HAS_ALL) {
/* if there is an "all instances" for the metric, it will be
* the only optreq_t for the metric
*/
rqp = findoptreq(pmid, 0);
ctp = (task_t *)rqp->r_fetch->f_aux;
/* if the metric is "advisory on, all instances" and the
* request is for "mandatory maybe, all instances" the current
* advisory logging state of the metric is retained
*/
if (PMLC_GET_MAND(ctp->t_state) == 0 && PMLC_GET_MAYBE(reqstate))
return 0;
/* advisory off & mandatory maybe metrics don't get put into
* the data structure
*/
if (PMLC_GET_MAYBE(reqstate) ||
(PMLC_GET_MAND(reqstate) == 0 && PMLC_GET_ON(reqstate) == 0)) {
del_optreq(rqp);
return 0;
}
addpmid = 1;
if ((sts = __pmOptFetchDel(&ctp->t_fetch, rqp)) < 0)
die("update_metric: all inst __pmOptFetchDel", sts);
/* don't delete from hash list, rqp re-used */
__pmOptFetchAdd(&ntp->t_fetch, rqp);
linkback(ntp);
}
else {
/* there are one or more specific instances for the metric.
* The metric cannot have an "all instances" at the same time.
*
* if the request is for "mandatory maybe, all instances" and
* the only instances of the metric all have advisory logging
* on, retain the current advisory semantics.
*/
if (PMLC_GET_MAYBE(reqstate) &&
(mflags & MF_HAS_INST) && !(mflags & MF_HAS_MAND))
return 0;
dp = del_insts(pmid);
/* advisory off (mandatory maybe) metrics don't get put into
* the data structure
*/
if (PMLC_GET_MAYBE(reqstate) ||
(PMLC_GET_MAND(reqstate) == 0 && PMLC_GET_ON(reqstate) == 0)) {
free(dp);
return 0;
}
addpmid = 1;
rqp = (optreq_t *)calloc(1, sizeof(optreq_t));
if (rqp == NULL) {
__pmNoMem("update_metric: all inst calloc",
sizeof(optreq_t), PM_FATAL_ERR);
}
rqp->r_desc = dp;
__pmOptFetchAdd(&ntp->t_fetch, rqp);
linkback(ntp);
if ((sts = __pmHashAdd(pmid, (void *)rqp, &pm_hash)) < 0)
die("update_metric: all inst __pmHashAdd", sts);
}
}
}
if (!addpmid)
return 0;
/* add pmid to new task if not already there */
for (i = 0; i < ntp->t_numpmid; i++)
if (pmid == ntp->t_pmidlist[i])
break;
if (i >= ntp->t_numpmid) {
pmDesc desc;
char *name;
int need;
if ((sts = pmLookupDesc(pmid, &desc)) < 0)
die("update_metric: cannot lookup desc", sts);
if ((sts = pmNameID(pmid, &name)) < 0)
die("update_metric: cannot lookup name", sts);
need = (ntp->t_numpmid + 1) * sizeof(pmID);
if (!(ntp->t_pmidlist = (pmID *)realloc(ntp->t_pmidlist, need)))
__pmNoMem("update_metric: grow task pmidlist", need, PM_FATAL_ERR);
need = (ntp->t_numpmid + 1) * sizeof(char *);
if (!(ntp->t_namelist = (char **)realloc(ntp->t_namelist, need)))
__pmNoMem("update_metric: grow task namelist", need, PM_FATAL_ERR);
need = (ntp->t_numpmid + 1) * sizeof(pmDesc);
if (!(ntp->t_desclist = (pmDesc *)realloc(ntp->t_desclist, need)))
__pmNoMem("update_metric: grow task desclist", need, PM_FATAL_ERR);
i = ntp->t_numpmid;
ntp->t_pmidlist[i] = pmid;
ntp->t_namelist[i] = name;
ntp->t_desclist[i] = desc;
ntp->t_numpmid++;
}
return 0;
}
/* Add a new metric (given a pmValueSet and a pmDesc) to the specified task.
* Allocate and return a new task_t if the specified task pointer is nil.
*
* Note that this should only be called for metrics not currently in the
* logging data structure. All instances in the pmValueSet are added!
*/
static int
add_metric(pmValueSet *vsp, task_t **result)
{
pmID pmid = vsp->pmid;
task_t *tp = *result;
optreq_t *rqp;
pmDesc *dp;
char *name;
int sts, i, need = 0;
dp = (pmDesc *)malloc(sizeof(pmDesc));
if (dp == NULL) {
__pmNoMem("add_metric: new pmDesc malloc", sizeof(pmDesc), PM_FATAL_ERR);
}
if ((sts = pmLookupDesc(pmid, dp)) < 0)
die("add_metric: lookup desc", sts);
if ((sts = pmNameID(pmid, &name)) < 0)
die("add_metric: lookup name", sts);
/* allocate a new task if null task pointer passed in */
if (tp == NULL) {
tp = calloc(1, sizeof(task_t));
if (tp == NULL) {
__pmNoMem("add_metric: new task calloc", sizeof(task_t), PM_FATAL_ERR);
}
*result = tp;
}
/* add metric (and any instances specified) to task */
i = tp->t_numpmid++;
need = tp->t_numpmid * sizeof(pmID);
if (!(tp->t_pmidlist = (pmID *)realloc(tp->t_pmidlist, need)))
__pmNoMem("add_metric: new task pmidlist realloc", need, PM_FATAL_ERR);
need = tp->t_numpmid * sizeof(char *);
if (!(tp->t_namelist = (char **)realloc(tp->t_namelist, need)))
__pmNoMem("add_metric: new task namelist realloc", need, PM_FATAL_ERR);
need = tp->t_numpmid * sizeof(pmDesc);
if (!(tp->t_desclist = (pmDesc *)realloc(tp->t_desclist, need)))
__pmNoMem("add_metric: new task desclist realloc", need, PM_FATAL_ERR);
tp->t_pmidlist[i] = pmid;
tp->t_namelist[i] = name;
tp->t_desclist[i] = *dp; /* struct assignment */
rqp = (optreq_t *)calloc(1, sizeof(optreq_t));
if (rqp == NULL) {
__pmNoMem("add_metric: new task optreq calloc", need, PM_FATAL_ERR);
}
rqp->r_desc = dp;
/* Now copy instances if required. Remember that metrics with singular
* values actually have one instance specified to distinguish them from the
* "all instances" case (which has no instances). Use the pmDesc to check
* for this.
*/
if (dp->indom != PM_INDOM_NULL)
need = rqp->r_numinst = vsp->numval;
if (need) {
need *= sizeof(rqp->r_instlist[0]);
rqp->r_instlist = (int *)malloc(need);
if (rqp->r_instlist == NULL) {
__pmNoMem("add_metric: new task optreq instlist malloc", need,
PM_FATAL_ERR);
}
for (i = 0; i < vsp->numval; i++)
rqp->r_instlist[i] = vsp->vlist[i].inst;
}
/* Add new metric to task's fetchgroup(s) and global hash table */
__pmOptFetchAdd(&tp->t_fetch, rqp);
linkback(tp);
if ((sts = __pmHashAdd(pmid, (void *)rqp, &pm_hash)) < 0)
die("add_metric: __pmHashAdd", sts);
return 0;
}
/*
* Handle event records.
*
* Walk the packed array of events using similar logic to
* pmUnpackEventRecords() but we don't need any allocations.
*
* For each embedded event parameter, make sure the metadata for
* the associated metric is added to the archive.
*/
int
do_events(pmValueSet *vsp)
{
pmEventArray *eap;
char *base;
pmEventRecord *erp;
pmEventParameter *epp;
int r; /* records */
int p; /* parameters in a record ... */
int i; /* instances ... */
int sts;
pmDesc desc;
for (i = 0; i < vsp->numval; i++) {
if ((sts = __pmCheckEventRecords(vsp, i)) < 0) {
__pmDumpEventRecords(stderr, vsp, i);
return sts;
}
eap = (pmEventArray *)vsp->vlist[i].value.pval;
if (eap->ea_nrecords == 0)
return 0;
base = (char *)&eap->ea_record[0];
for (r = 0; r < eap->ea_nrecords; r++) {
erp = (pmEventRecord *)base;
base += sizeof(erp->er_timestamp) + sizeof(erp->er_flags) + sizeof(erp->er_nparams);
if (erp->er_flags & PM_EVENT_FLAG_MISSED) {
/*
* no event "parameters" here, just a missed records count
* in er_nparams
*/
continue;
}
for (p = 0; p < erp->er_nparams; p++) {
epp = (pmEventParameter *)base;
base += sizeof(epp->ep_pmid) + PM_PDU_SIZE_BYTES(epp->ep_len);
sts = __pmLogLookupDesc(&logctl, epp->ep_pmid, &desc);
if (sts < 0) {
int numnames;
char **names;
numnames = pmNameAll(epp->ep_pmid, &names);
if (numnames < 0) {
/*
* Event parameter metric not defined in the PMNS.
* This should not happen, but is probably not fatal, so
* issue a warning and make up a name based on the pmid
* event_param.<domain>.<cluster>.<item>
*/
char *name;
size_t name_size = strlen("event_param")+3+1+4+1+4+1;
names = (char **)malloc(sizeof(char*) + name_size);
if (names == NULL)
return -oserror();
name = (char *)&names[1];
names[0] = name;
snprintf(name, name_size, "event_param.%s", pmIDStr(epp->ep_pmid));
fprintf(stderr, "Warning: metric %s has no name, using %s\n", pmIDStr(epp->ep_pmid), name);
}
sts = pmLookupDesc(epp->ep_pmid, &desc);
if (sts < 0) {
/* Event parameter metric does not have a pmDesc.
* This should not happen, but is probably not entirely
* fatal (although more serious than not having a metric
* name), issue a warning and construct a minimalist
* pmDesc
*/
desc.pmid = epp->ep_pmid;
desc.type = PM_TYPE_AGGREGATE;
desc.indom = PM_INDOM_NULL;
desc.sem = PM_SEM_DISCRETE;
memset(&desc.units, '\0', sizeof(desc.units));
fprintf(stderr, "Warning: metric %s (%s) has no descriptor, using a default one\n", names[0], pmIDStr(epp->ep_pmid));
}
if ((sts = __pmLogPutDesc(&logctl, &desc, numnames, names)) < 0) {
fprintf(stderr, "__pmLogPutDesc: %s\n", pmErrStr(sts));
exit(1);
}
free(names);
}
}
}
}
return 0;
}
int
main(int argc, char **argv)
{
int sts;
int n;
int c;
int i;
char *p;
char *source;
char *namelist[1];
pmID pmidlist[1];
pmResult *result;
char **instnames = NULL;
int numinst = 0;
int force = 0;
pmDesc desc;
pmAtomValue nav;
pmValueSet *vsp;
char *subopt;
while ((c = pmGetOptions(argc, argv, &opts)) != EOF) {
switch (c) {
case 'f':
force++;
break;
case 'i': /* list of instances */
#define WHITESPACE ", \t\n"
subopt = strtok(opts.optarg, WHITESPACE);
while (subopt != NULL) {
numinst++;
n = numinst * sizeof(char *);
instnames = (char **)realloc(instnames, n);
if (instnames == NULL)
__pmNoMem("pmstore.instnames", n, PM_FATAL_ERR);
instnames[numinst-1] = subopt;
subopt = strtok(NULL, WHITESPACE);
}
#undef WHITESPACE
break;
default:
opts.errors++;
break;
}
}
if (opts.errors || opts.optind != argc - 2) {
pmUsageMessage(&opts);
exit(1);
}
if (opts.context == PM_CONTEXT_HOST)
source = opts.hosts[0];
else if (opts.context == PM_CONTEXT_LOCAL)
source = NULL;
else {
opts.context = PM_CONTEXT_HOST;
source = "local:";
}
if ((sts = pmNewContext(opts.context, source)) < 0) {
if (opts.context == PM_CONTEXT_LOCAL)
fprintf(stderr, "%s: Cannot make standalone local connection: %s\n",
pmProgname, pmErrStr(sts));
else
fprintf(stderr, "%s: Cannot connect to PMCD on host \"%s\": %s\n",
pmProgname, source, pmErrStr(sts));
exit(1);
}
namelist[0] = argv[opts.optind++];
if ((n = pmLookupName(1, namelist, pmidlist)) < 0) {
printf("%s: pmLookupName: %s\n", namelist[0], pmErrStr(n));
exit(1);
}
if (pmidlist[0] == PM_ID_NULL) {
printf("%s: unknown metric\n", namelist[0]);
exit(1);
}
if ((n = pmLookupDesc(pmidlist[0], &desc)) < 0) {
printf("%s: pmLookupDesc: %s\n", namelist[0], pmErrStr(n));
exit(1);
}
if (desc.type == PM_TYPE_AGGREGATE || desc.type == PM_TYPE_AGGREGATE_STATIC) {
fprintf(stderr, "%s: Cannot modify values for PM_TYPE_AGGREGATE metrics\n",
pmProgname);
exit(1);
}
if (desc.type == PM_TYPE_EVENT || desc.type == PM_TYPE_HIGHRES_EVENT) {
fprintf(stderr, "%s: Cannot modify values for event type metrics\n",
pmProgname);
exit(1);
}
if (instnames != NULL) {
pmDelProfile(desc.indom, 0, NULL);
for (i = 0; i < numinst; i++) {
if ((n = pmLookupInDom(desc.indom, instnames[i])) < 0) {
printf("pmLookupInDom %s[%s]: %s\n",
namelist[0], instnames[i], pmErrStr(n));
exit(1);
}
if ((sts = pmAddProfile(desc.indom, 1, &n)) < 0) {
printf("pmAddProfile %s[%s]: %s\n",
namelist[0], instnames[i], pmErrStr(sts));
exit(1);
}
}
}
if ((n = pmFetch(1, pmidlist, &result)) < 0) {
printf("%s: pmFetch: %s\n", namelist[0], pmErrStr(n));
exit(1);
}
/* value is argv[opts.optind] */
mkAtom(&nav, desc.type, argv[opts.optind]);
vsp = result->vset[0];
if (vsp->numval < 0) {
printf("%s: Error: %s\n", namelist[0], pmErrStr(vsp->numval));
exit(1);
}
if (vsp->numval == 0) {
if (!force) {
printf("%s: No value(s) available!\n", namelist[0]);
exit(1);
}
else {
pmAtomValue tmpav;
mkAtom(&tmpav, PM_TYPE_STRING, "(none)");
vsp->numval = 1;
vsp->valfmt = __pmStuffValue(&tmpav, &vsp->vlist[0], PM_TYPE_STRING);
}
}
for (i = 0; i < vsp->numval; i++) {
pmValue *vp = &vsp->vlist[i];
printf("%s", namelist[0]);
if (desc.indom != PM_INDOM_NULL) {
if ((n = pmNameInDom(desc.indom, vp->inst, &p)) < 0)
printf(" inst [%d]", vp->inst);
else {
printf(" inst [%d or \"%s\"]", vp->inst, p);
free(p);
}
}
printf(" old value=");
pmPrintValue(stdout, vsp->valfmt, desc.type, vp, 1);
vsp->valfmt = __pmStuffValue(&nav, &vsp->vlist[i], desc.type);
printf(" new value=");
pmPrintValue(stdout, vsp->valfmt, desc.type, vp, 1);
putchar('\n');
}
if ((n = pmStore(result)) < 0) {
printf("%s: pmStore: %s\n", namelist[0], pmErrStr(n));
exit(1);
}
pmFreeResult(result);
exit(0);
}
int
main(int argc, char *argv[])
{
int c;
int sts;
char *endnum;
pmDesc desc;
int one_trip = 1;
while ((c = pmGetOptions(argc, argv, &opts)) != EOF) {
switch (c) {
case 'w': /* wide flag */
line_fmt = "%.1024s";
break;
case 'p': /* show flag */
if (one_trip) {
show_spec = 0;
one_trip = 0;
}
if ((sts = parse_show_spec(opts.optarg)) < 0) {
pmprintf("%s: unrecognized print flag specification (%s)\n",
pmProgname, opts.optarg);
opts.errors++;
} else {
show_spec |= sts;
}
break;
case 'm': /* top N */
top = (int)strtol(opts.optarg, &endnum, 10);
if (top <= 0) {
pmprintf("%s: -m requires a positive integer\n", pmProgname);
opts.errors++;
}
break;
}
}
if (opts.optind < argc)
opts.errors++;
if (opts.errors) {
pmUsageMessage(&opts);
exit(1);
}
create_namelist();
if (opts.interval.tv_sec == 0)
opts.interval.tv_sec = 2;
if (opts.nhosts > 0)
hostname = opts.hosts[0];
else
hostname = "local:";
if ((sts = c = pmNewContext(PM_CONTEXT_HOST, hostname)) < 0) {
fprintf(stderr, "%s: Cannot connect to PMCD on host \"%s\": %s\n",
pmProgname, hostname, pmErrStr(sts));
exit(1);
}
hostname = (char *)pmGetContextHostName(c);
if (pmGetContextOptions(c, &opts)) {
pmflush();
exit(1);
}
if ((sts = pmLookupName(num_pmid, namelist, pmidlist)) < 0) {
fprintf(stderr, "%s: Failed to lookup metrics : %s\n",
pmProgname, pmErrStr(sts));
exit(1);
}
for (c = 0; c < num_pmid; c++) {
if ((sts = pmLookupDesc(pmidlist[c], &desc)) < 0) {
fprintf(stderr, "%s: Failed to lookup descriptor for metric \"%s\": %s\n",
pmProgname, namelist[c], pmErrStr(sts));
exit(1);
}
type_tab[c] = desc.type;
/* ASSUMES that the first metric will always be a proc metric */
if (c == 0) {
proc_indom = desc.indom;
}
}
for (;;) {
doit();
__pmtimevalSleep(opts.interval);
}
return 0;
}
int
main(int argc, char **argv)
{
pthread_t tid1;
pthread_t tid2;
pthread_t tid3;
int sts;
char *msg;
int errflag = 0;
int c;
int i;
pmSetProgname(argv[0]);
while ((c = getopt(argc, argv, "D:")) != EOF) {
switch (c) {
case 'D': /* debug options */
sts = pmSetDebug(optarg);
if (sts < 0) {
fprintf(stderr, "%s: unrecognized debug options specification (%s)\n",
pmGetProgname(), optarg);
errflag++;
}
break;
case '?':
default:
errflag++;
break;
}
}
if (errflag || optind == argc || argc-optind > 3) {
fprintf(stderr, "Usage: %s [-D...] host1 [host2 [host3]]\n", pmGetProgname());
exit(1);
}
ctx1 = pmNewContext(PM_CONTEXT_HOST, argv[optind]);
if (ctx1 < 0) {
printf("Error: pmNewContext(%s) -> %s\n", argv[optind], pmErrStr(ctx1));
exit(1);
}
optind++;
if (optind < argc) {
ctx2 = pmNewContext(PM_CONTEXT_HOST, argv[optind]);
if (ctx2 < 0) {
printf("Error: pmNewContext(%s) -> %s\n", argv[optind], pmErrStr(ctx2));
exit(1);
}
optind++;
}
else
ctx2 = ctx1;
if (optind < argc) {
ctx3 = pmNewContext(PM_CONTEXT_HOST, argv[optind]);
if (ctx3 < 0) {
printf("Error: pmNewContext(%s) -> %s\n", argv[optind], pmErrStr(ctx2));
exit(1);
}
optind++;
}
else
ctx3 = ctx2;
sts = pmLookupName(NMETRIC, namelist, pmidlist);
if (sts != NMETRIC) {
if (sts < 0)
printf("Warning: pmLookupName -> %s\n", pmErrStr(sts));
else
printf("Warning: pmLookupName returned %d, expected %d\n", sts, (int)(NMETRIC));
for (i = 0; i < NMETRIC; i++) {
printf(" %s -> %s", namelist[i], pmIDStr(pmidlist[i]));
if (pmidlist[i] == PM_ID_NULL) {
sts = pmLookupName(1, &namelist[i], &pmidlist[i]);
printf(": %s", pmErrStr(sts));
}
putchar('\n');
}
}
for (i = 0; i < NMETRIC; i++) {
if (pmidlist[i] != PM_ID_NULL) {
if ((sts = pmLookupDesc(pmidlist[i], &desclist[i])) < 0) {
printf("Error: pmLookupDesc(%s) -> %s\n", namelist[i], pmErrStr(sts));
exit(1);
}
}
chn[i] = NULL;
leaf_chn[i] = nonleaf_chn[i] = -1;
}
sts = pthread_barrier_init(&barrier, NULL, 3);
if (sts != 0) {
printf("pthread_barrier_init: sts=%d\n", sts);
exit(1);
}
sts = pthread_create(&tid1, NULL, func1, NULL);
if (sts != 0) {
printf("thread_create: tid1: sts=%d\n", sts);
exit(1);
}
sts = pthread_create(&tid2, NULL, func2, NULL);
if (sts != 0) {
printf("thread_create: tid2: sts=%d\n", sts);
exit(1);
}
sts = pthread_create(&tid3, NULL, func3, NULL);
if (sts != 0) {
printf("thread_create: tid3: sts=%d\n", sts);
exit(1);
}
pthread_join(tid1, (void *)&msg);
if (msg != NULL) printf("tid1: %s\n", msg);
pthread_join(tid2, (void *)&msg);
if (msg != NULL) printf("tid2: %s\n", msg);
pthread_join(tid3, (void *)&msg);
if (msg != NULL) printf("tid3: %s\n", msg);
exit(0);
}
static void
report(void)
{
int i;
int sts;
pmDesc desc;
pmResult *result = NULL;
pmResult *xresult = NULL;
pmValueSet *vsp = NULL;
char *buffer;
int all_count;
int *all_inst;
char **all_names;
if (batchidx == 0)
return;
/* Lookup names.
* Cull out names that were unsuccessfully looked up.
* However, it is unlikely to fail because names come from a traverse PMNS.
*/
if (need_pmid) {
if ((sts = pmLookupName(batchidx, namelist, pmidlist)) < 0) {
int j = 0;
for (i = 0; i < batchidx; i++) {
if (pmidlist[i] == PM_ID_NULL) {
printf("%s: pmLookupName: %s\n", namelist[i], pmErrStr(sts));
free(namelist[i]);
}
else {
/* assert(j <= i); */
pmidlist[j] = pmidlist[i];
namelist[j] = namelist[i];
j++;
}
}
batchidx = j;
}
}
if (p_value || verify) {
if (opts.context == PM_CONTEXT_ARCHIVE) {
if ((sts = pmSetMode(PM_MODE_FORW, &opts.origin, 0)) < 0) {
fprintf(stderr, "%s: pmSetMode failed: %s\n", pmProgname, pmErrStr(sts));
exit(1);
}
}
if ((sts = pmFetch(batchidx, pmidlist, &result)) < 0) {
for (i = 0; i < batchidx; i++)
printf("%s: pmFetch: %s\n", namelist[i], pmErrStr(sts));
goto done;
}
}
for (i = 0; i < batchidx; i++) {
if (p_desc || p_value || verify) {
if ((sts = pmLookupDesc(pmidlist[i], &desc)) < 0) {
printf("%s: pmLookupDesc: %s\n", namelist[i], pmErrStr(sts));
continue;
}
}
if (p_desc || p_help || p_value)
/* Not doing verify, output separator */
putchar('\n');
if (p_value || verify) {
vsp = result->vset[i];
if (p_force) {
if (result->vset[i]->numval == PM_ERR_PROFILE) {
/* indom is non-enumerable; try harder */
if ((all_count = pmGetInDom(desc.indom, &all_inst, &all_names)) > 0) {
pmDelProfile(desc.indom, 0, NULL);
pmAddProfile(desc.indom, all_count, all_inst);
if (xresult != NULL) {
pmFreeResult(xresult);
xresult = NULL;
}
if (opts.context == PM_CONTEXT_ARCHIVE) {
if ((sts = pmSetMode(PM_MODE_FORW, &opts.origin, 0)) < 0) {
fprintf(stderr, "%s: pmSetMode failed: %s\n", pmProgname, pmErrStr(sts));
exit(1);
}
}
if ((sts = pmFetch(1, &pmidlist[i], &xresult)) < 0) {
printf("%s: pmFetch: %s\n", namelist[i], pmErrStr(sts));
continue;
}
vsp = xresult->vset[0];
/* leave the profile in the default state */
free(all_inst);
free(all_names);
pmDelProfile(desc.indom, 0, NULL);
pmAddProfile(desc.indom, 0, NULL);
}
else if (all_count == 0) {
printf("%s: pmGetIndom: No instances?\n", namelist[i]);
continue;
}
else {
printf("%s: pmGetIndom: %s\n", namelist[i], pmErrStr(all_count));
continue;
}
}
}
}
if (verify) {
if (desc.type == PM_TYPE_NOSUPPORT)
printf("%s: Not Supported\n", namelist[i]);
else if (vsp->numval < 0)
printf("%s: %s\n", namelist[i], pmErrStr(vsp->numval));
else if (vsp->numval == 0)
printf("%s: No value(s) available\n", namelist[i]);
continue;
}
else
/* not verify */
printf("%s", namelist[i]);
if (p_mid)
printf(" PMID: %s", pmIDStr(pmidlist[i]));
if (p_fullmid)
printf(" = %d = 0x%x", pmidlist[i], pmidlist[i]);
if (p_oneline) {
if ((sts = pmLookupText(pmidlist[i], PM_TEXT_ONELINE, &buffer)) == 0) {
if (p_fullmid)
printf("\n ");
else
putchar(' ');
printf("[%s]", buffer);
free(buffer);
}
else
printf(" One-line Help: Error: %s\n", pmErrStr(sts));
}
putchar('\n');
if (p_desc)
__pmPrintDesc(stdout, &desc);
if (p_help) {
if ((sts = pmLookupText(pmidlist[i], PM_TEXT_HELP, &buffer)) == 0) {
char *p;
for (p = buffer; *p; p++)
;
while (p > buffer && p[-1] == '\n') {
p--;
*p = '\0';
}
if (*buffer != '\0') {
printf("Help:\n");
printf("%s", buffer);
putchar('\n');
}
else
printf("Help: <empty entry>\n");
free(buffer);
}
else
printf("Full Help: Error: %s\n", pmErrStr(sts));
}
if (p_value) {
mydump(&desc, vsp, NULL);
}
}
if (result != NULL) {
pmFreeResult(result);
result = NULL;
}
if (xresult != NULL) {
pmFreeResult(xresult);
xresult = NULL;
}
done:
for (i = 0; i < batchidx; i++)
free(namelist[i]);
batchidx = 0;
}
static void
get_sample(info_t *ip)
{
static pmResult *crp = NULL; /* current */
static pmResult *prp = NULL; /* prior */
static int first = 1;
static int numpmid;
static pmID *pmidlist;
static pmDesc *desclist;
static int inst1;
static int inst15;
static pmUnits mbyte_scale;
int sts;
int i;
float u;
pmAtomValue tmp;
pmAtomValue atom;
double dt;
if (first) {
/* first time initialization */
mbyte_scale.dimSpace = 1;
mbyte_scale.scaleSpace = PM_SPACE_MBYTE;
numpmid = sizeof(pmclient_sample) / sizeof(char *);
if ((pmidlist = (pmID *)malloc(numpmid * sizeof(pmidlist[0]))) == NULL) {
fprintf(stderr, "%s: get_sample: malloc: %s\n", pmProgname, osstrerror());
exit(1);
}
if ((desclist = (pmDesc *)malloc(numpmid * sizeof(desclist[0]))) == NULL) {
fprintf(stderr, "%s: get_sample: malloc: %s\n", pmProgname, osstrerror());
exit(1);
}
if ((sts = pmLookupName(numpmid, pmclient_sample, pmidlist)) < 0) {
printf("%s: pmLookupName: %s\n", pmProgname, pmErrStr(sts));
for (i = 0; i < numpmid; i++) {
if (pmidlist[i] == PM_ID_NULL)
fprintf(stderr, "%s: metric \"%s\" not in name space\n", pmProgname, pmclient_sample[i]);
}
exit(1);
}
for (i = 0; i < numpmid; i++) {
if ((sts = pmLookupDesc(pmidlist[i], &desclist[i])) < 0) {
fprintf(stderr, "%s: cannot retrieve description for metric \"%s\" (PMID: %s)\nReason: %s\n",
pmProgname, pmclient_sample[i], pmIDStr(pmidlist[i]), pmErrStr(sts));
exit(1);
}
}
}
/* fetch the current metrics */
if ((sts = pmFetch(numpmid, pmidlist, &crp)) < 0) {
fprintf(stderr, "%s: pmFetch: %s\n", pmProgname, pmErrStr(sts));
exit(1);
}
/*
* minor gotcha ... for archives, it helps to do the first fetch of
* real data before interrogating the instance domains ... this
* forces us to be "after" the first batch of instance domain info
* in the meta data files
*/
if (first) {
/*
* from now on, just want the 1 minute and 15 minute load averages,
* so limit the instance profile for this metric
*/
pmDelProfile(desclist[LOADAV].indom, 0, NULL); /* all off */
if ((inst1 = pmLookupInDom(desclist[LOADAV].indom, "1 minute")) < 0) {
fprintf(stderr, "%s: cannot translate instance for 1 minute load average\n", pmProgname);
exit(1);
}
pmAddProfile(desclist[LOADAV].indom, 1, &inst1);
if ((inst15 = pmLookupInDom(desclist[LOADAV].indom, "15 minute")) < 0) {
fprintf(stderr, "%s: cannot translate instance for 15 minute load average\n", pmProgname);
exit(1);
}
pmAddProfile(desclist[LOADAV].indom, 1, &inst15);
first = 0;
}
/* if the second or later sample, pick the results apart */
if (prp != NULL) {
dt = __pmtimevalSub(&crp->timestamp, &prp->timestamp);
ip->cpu_util = 0;
ip->peak_cpu_util = -1; /* force re-assignment at first CPU */
for (i = 0; i < ncpu; i++) {
pmExtractValue(crp->vset[CPU_USR]->valfmt,
&crp->vset[CPU_USR]->vlist[i],
desclist[CPU_USR].type, &atom, PM_TYPE_FLOAT);
u = atom.f;
pmExtractValue(prp->vset[CPU_USR]->valfmt,
&prp->vset[CPU_USR]->vlist[i],
desclist[CPU_USR].type, &atom, PM_TYPE_FLOAT);
u -= atom.f;
pmExtractValue(crp->vset[CPU_SYS]->valfmt,
&crp->vset[CPU_SYS]->vlist[i],
desclist[CPU_SYS].type, &atom, PM_TYPE_FLOAT);
u += atom.f;
pmExtractValue(prp->vset[CPU_SYS]->valfmt,
&prp->vset[CPU_SYS]->vlist[i],
desclist[CPU_SYS].type, &atom, PM_TYPE_FLOAT);
u -= atom.f;
/*
* really should use pmConvertValue, but I _know_ the times
* are in msec!
*/
u = u / (1000 * dt);
if (u > 1.0)
/* small errors are possible, so clip the utilization at 1.0 */
u = 1.0;
ip->cpu_util += u;
if (u > ip->peak_cpu_util) {
ip->peak_cpu_util = u;
ip->peak_cpu = i;
}
}
ip->cpu_util /= ncpu;
/* freemem - expect just one value */
pmExtractValue(crp->vset[FREEMEM]->valfmt, crp->vset[FREEMEM]->vlist,
desclist[FREEMEM].type, &tmp, PM_TYPE_FLOAT);
/* convert from today's units at the collection site to Mbytes */
pmConvScale(PM_TYPE_FLOAT, &tmp, &desclist[FREEMEM].units,
&atom, &mbyte_scale);
ip->freemem = atom.f;
/* disk IOPS - expect just one value, but need delta */
pmExtractValue(crp->vset[DKIOPS]->valfmt, crp->vset[DKIOPS]->vlist,
desclist[DKIOPS].type, &atom, PM_TYPE_U32);
ip->dkiops = atom.ul;
pmExtractValue(prp->vset[DKIOPS]->valfmt, prp->vset[DKIOPS]->vlist,
desclist[DKIOPS].type, &atom, PM_TYPE_U32);
ip->dkiops -= atom.ul;
ip->dkiops = ((float)(ip->dkiops) + 0.5) / dt;
/* load average ... process all values, matching up the instances */
for (i = 0; i < crp->vset[LOADAV]->numval; i++) {
pmExtractValue(crp->vset[LOADAV]->valfmt,
&crp->vset[LOADAV]->vlist[i],
desclist[LOADAV].type, &atom, PM_TYPE_FLOAT);
if (crp->vset[LOADAV]->vlist[i].inst == inst1)
ip->load1 = atom.f;
else if (crp->vset[LOADAV]->vlist[i].inst == inst15)
ip->load15 = atom.f;
}
/* free very old result */
pmFreeResult(prp);
}
ip->timestamp = crp->timestamp;
/* swizzle result pointers */
prp = crp;
}
static void
dometric(const char *name)
{
int n;
pmID pmidlist[] = { PM_ID_NULL };
pmDesc desc;
int *instlist = NULL;
char **instname = NULL;
pmResult *result;
extern int pmDebug;
_metrics++;
/* cast const away as pmLookupName will not modify this string */
if ((n = pmLookupName(1, (char **)&name, pmidlist)) < 0) {
printf("%s: pmLookupName: %s\n", name, pmErrStr(n));
return;
}
if ((n = pmLookupDesc(pmidlist[0], &desc)) < 0) {
printf("%s: pmLookupDesc: %s\n", name, pmErrStr(n));
return;
}
if (desc.indom != PM_INDOM_NULL) {
_indom++;
if ((n = pmGetInDom(desc.indom, &instlist, &instname)) < 0) {
printf("%s: pmGetInDom: %s\n", name, pmErrStr(n));
return;
}
if (instlist)
free(instlist);
if (instname)
free(instname);
}
if ((n = pmFetch(1, pmidlist, &result)) < 0) {
printf("%s: pmFetch: %s\n", name, pmErrStr(n));
return;
}
if (result->numpmid != 1) {
printf("%s: pmFetch: numpmid=%d, not 1\n", name, result->numpmid);
}
else {
if (result->vset[0]->numval == 0)
printf("%s: pmFetch: no value available\n", name);
else if (result->vset[0]->numval < 0)
printf("%s: pmFetch: %s\n", name, pmErrStr(result->vset[0]->numval));
else {
if (result->vset[0]->valfmt == PM_VAL_INSITU) {
_insitu++;
if (pmDebug && DBG_TRACE_APPL0)
printf("%s: insitu type=%s\n", name, pmTypeStr(desc.type));
}
else {
_ptr++;
if (pmDebug && DBG_TRACE_APPL0)
printf("%s: ptr size=%d valtype=%d descrtype=%s\n",
name,
result->vset[0]->vlist[0].value.pval->vlen,
result->vset[0]->vlist[0].value.pval->vtype,
pmTypeStr(desc.type));
}
}
}
pmFreeResult(result);
}
static void
dump_result(pmResult *resp)
{
int i;
int j;
int n;
char **names;
pmDesc desc;
if (sflag) {
int nbyte;
nbyte = do_size(resp);
printf("[%d bytes]\n", nbyte);
}
if (xflag) {
char *ddmm;
char *yr;
ddmm = pmCtime(&resp->timestamp.tv_sec, timebuf);
ddmm[10] = '\0';
yr = &ddmm[20];
printf("%s ", ddmm);
__pmPrintStamp(stdout, &resp->timestamp);
printf(" %4.4s", yr);
if (xflag >= 2)
printf(" (%.6f)", __pmtimevalSub(&resp->timestamp, &label.ll_start));
}
else
__pmPrintStamp(stdout, &resp->timestamp);
if (resp->numpmid == 0) {
printf(" <mark>\n");
return;
}
for (i = 0; i < resp->numpmid; i++) {
pmValueSet *vsp = resp->vset[i];
if (i > 0)
printf(" ");
n = pmNameAll(vsp->pmid, &names);
if (vsp->numval == 0) {
printf(" %s (", pmIDStr(vsp->pmid));
__pmPrintMetricNames(stdout, n, names, " or ");
printf("): No values returned!\n");
goto next;
}
else if (vsp->numval < 0) {
printf(" %s (", pmIDStr(vsp->pmid));
__pmPrintMetricNames(stdout, n, names, " or ");
printf("): %s\n", pmErrStr(vsp->numval));
goto next;
}
if (pmLookupDesc(vsp->pmid, &desc) < 0) {
/* don't know, so punt on the most common cases */
desc.indom = PM_INDOM_NULL;
if (vsp->valfmt == PM_VAL_INSITU)
desc.type = PM_TYPE_32;
else
desc.type = PM_TYPE_AGGREGATE;
}
for (j = 0; j < vsp->numval; j++) {
if (desc.type == PM_TYPE_EVENT ||
desc.type == PM_TYPE_HIGHRES_EVENT)
dump_event(n, names, vsp, j, desc.indom, desc.type);
else
dump_metric(n, names, vsp, j, desc.indom, desc.type);
}
next:
if (n > 0)
free(names);
}
}
/* reinitialize Metric - only for live host */
int /* 1: ok, 0: try again later, -1: fail */
reinitMetric(Metric *m)
{
char *hname = symName(m->hname);
char *mname = symName(m->mname);
char **inames;
int *iids;
int handle;
int ret = 1;
int sts;
int i, j;
/* set up temporary context */
if ((handle = newContext(hname)) < 0)
return 0;
host_state_changed(hname, STATE_RECONN);
if ((sts = pmLookupName(1, &mname, &m->desc.pmid)) < 0) {
ret = 0;
goto end;
}
/* fill in performance metric descriptor */
if ((sts = pmLookupDesc(m->desc.pmid, &m->desc)) < 0) {
ret = 0;
goto end;
}
if (m->desc.type == PM_TYPE_STRING ||
m->desc.type == PM_TYPE_AGGREGATE ||
m->desc.type == PM_TYPE_AGGREGATE_STATIC ||
m->desc.type == PM_TYPE_EVENT ||
m->desc.type == PM_TYPE_HIGHRES_EVENT ||
m->desc.type == PM_TYPE_UNKNOWN) {
fprintf(stderr, "%s: metric %s has non-numeric type\n", pmProgname, mname);
ret = -1;
}
else if (m->desc.indom == PM_INDOM_NULL) {
if (m->specinst != 0) {
fprintf(stderr, "%s: metric %s has no instances\n", pmProgname, mname);
ret = -1;
}
else
m->m_idom = 1;
}
else {
if ((sts = pmGetInDom(m->desc.indom, &iids, &inames)) < 0) { /* full profile */
ret = 0;
}
else {
if (m->specinst == 0) {
/* all instances */
m->iids = iids;
m->m_idom = sts;
m->inames = alloc(m->m_idom*sizeof(char *));
for (i = 0; i < m->m_idom; i++) {
m->inames[i] = sdup(inames[i]);
}
}
else {
/* explicit instance profile */
m->m_idom = 0;
for (i = 0; i < m->specinst; i++) {
/* look for first matching instance name */
for (j = 0; j < sts; j++) {
if (eqinst(m->inames[i], inames[j])) {
m->iids[i] = iids[j];
m->m_idom++;
break;
}
}
if (j == sts) {
m->iids[i] = PM_IN_NULL;
ret = 0;
}
}
if (sts > 0) {
/*
* pmGetInDom or pmGetInDomArchive returned some
* instances above
*/
free(iids);
}
/*
* if specinst != m_idom, then some not found ... move these
* to the end of the list
*/
for (j = m->specinst-1; j >= 0; j--) {
if (m->iids[j] != PM_IN_NULL)
break;
}
for (i = 0; i < j; i++) {
if (m->iids[i] == PM_IN_NULL) {
/* need to swap */
char *tp;
tp = m->inames[i];
m->inames[i] = m->inames[j];
m->iids[i] = m->iids[j];
m->inames[j] = tp;
m->iids[j] = PM_IN_NULL;
j--;
}
}
}
#if PCP_DEBUG
if (pmDebug & DBG_TRACE_APPL1) {
int numinst;
fprintf(stderr, "reinitMetric: %s from %s: instance domain specinst=%d\n",
mname, hname, m->specinst);
if (m->m_idom < 1) fprintf(stderr, " %d instances!\n", m->m_idom);
if (m->specinst == 0) numinst = m->m_idom;
else numinst = m->specinst;
for (i = 0; i < numinst; i++) {
fprintf(stderr, " indom[%d]", i);
if (m->iids[i] == PM_IN_NULL)
fprintf(stderr, " ?missing");
else
fprintf(stderr, " %d", m->iids[i]);
fprintf(stderr, " \"%s\"\n", m->inames[i]);
}
}
#endif
if (sts > 0) {
/*
* pmGetInDom or pmGetInDomArchive returned some instances
* above
*/
free(inames);
}
}
}
if (ret == 1) {
/* compute conversion factor into canonical units
- non-zero conversion factor flags initialized metric */
m->conv = scale(m->desc.units);
/* automatic rate computation */
if (m->desc.sem == PM_SEM_COUNTER) {
m->vals = (double *) ralloc(m->vals, m->m_idom * sizeof(double));
for (j = 0; j < m->m_idom; j++)
m->vals[j] = 0;
}
}
if (ret >= 0) {
/*
* re-shape, starting here are working up the expression until
* we reach the top of the tree or the designated metrics
* associated with the node are not the same
*/
Expr *x = m->expr;
while (x) {
/*
* only re-shape expressions that may have set values
*/
if (x->op == CND_FETCH ||
x->op == CND_NEG || x->op == CND_ADD || x->op == CND_SUB ||
x->op == CND_MUL || x->op == CND_DIV ||
x->op == CND_SUM_HOST || x->op == CND_SUM_INST ||
x->op == CND_SUM_TIME ||
x->op == CND_AVG_HOST || x->op == CND_AVG_INST ||
x->op == CND_AVG_TIME ||
x->op == CND_MAX_HOST || x->op == CND_MAX_INST ||
x->op == CND_MAX_TIME ||
x->op == CND_MIN_HOST || x->op == CND_MIN_INST ||
x->op == CND_MIN_TIME ||
x->op == CND_EQ || x->op == CND_NEQ ||
x->op == CND_LT || x->op == CND_LTE ||
x->op == CND_GT || x->op == CND_GTE ||
x->op == CND_NOT || x->op == CND_AND || x->op == CND_OR ||
x->op == CND_RISE || x->op == CND_FALL || x->op == CND_INSTANT ||
x->op == CND_MATCH || x->op == CND_NOMATCH) {
instFetchExpr(x);
findEval(x);
#if PCP_DEBUG
if (pmDebug & DBG_TRACE_APPL1) {
fprintf(stderr, "reinitMetric: re-shaped ...\n");
dumpExpr(x);
}
#endif
}
if (x->parent) {
x = x->parent;
if (x->metrics == m)
continue;
}
break;
}
}
end:
/* destroy temporary context */
pmDestroyContext(handle);
return ret;
}
