int
__pmdaCntInst(pmInDom indom, pmdaExt *pmda)
{
int i;
int sts = 0;
if (indom == PM_INDOM_NULL)
return 1;
if (pmdaCacheOp(indom, PMDA_CACHE_CHECK)) {
sts = pmdaCacheOp(indom, PMDA_CACHE_SIZE_ACTIVE);
}
else {
for (i = 0; i < pmda->e_nindoms; i++) {
if (pmda->e_indoms[i].it_indom == indom) {
sts = pmda->e_indoms[i].it_numinst;
break;
}
}
if (i == pmda->e_nindoms) {
char strbuf[20];
__pmNotifyErr(LOG_WARNING, "cntinst: unknown indom %s", pmInDomStr_r(indom, strbuf, sizeof(strbuf)));
}
}
#ifdef PCP_DEBUG
if (pmDebug & DBG_TRACE_INDOM) {
char strbuf[20];
fprintf(stderr, "__pmdaCntInst(indom=%s) -> %d\n", pmInDomStr_r(indom, strbuf, sizeof(strbuf)), sts);
}
#endif
return sts;
}
int
__pmdaNextInst(int *inst, pmdaExt *pmda)
{
int j;
int myinst;
if (pmda->e_singular == 0) {
/* PM_INDOM_NULL ... just the one value */
*inst = 0;
pmda->e_singular = -1;
return 1;
}
if (pmda->e_ordinal >= 0) {
/* scan for next value in the profile */
if (pmda->e_idp == &last) {
/* cache-driven */
while ((myinst = pmdaCacheOp(pmda->e_idp->it_indom, PMDA_CACHE_WALK_NEXT)) != -1) {
pmda->e_ordinal++;
if (__pmInProfile(pmda->e_idp->it_indom, pmda->e_prof, myinst)) {
*inst = myinst;
#ifdef PCP_DEBUG
if (pmDebug & DBG_TRACE_INDOM) {
char strbuf[20];
fprintf(stderr, "__pmdaNextInst(indom=%s) -> %d e_ordinal=%d (cache)\n",
pmInDomStr_r(pmda->e_idp->it_indom, strbuf, sizeof(strbuf)), myinst, pmda->e_ordinal);
}
#endif
return 1;
}
}
}
else {
/* indomtab[]-driven */
for (j = pmda->e_ordinal; j < pmda->e_idp->it_numinst; j++) {
if (__pmInProfile(pmda->e_idp->it_indom,
pmda->e_prof,
pmda->e_idp->it_set[j].i_inst)) {
*inst = pmda->e_idp->it_set[j].i_inst;
pmda->e_ordinal = j+1;
#ifdef PCP_DEBUG
if (pmDebug & DBG_TRACE_INDOM) {
char strbuf[20];
fprintf(stderr, "__pmdaNextInst(indom=%s) -> %d e_ordinal=%d\n",
pmInDomStr_r(pmda->e_idp->it_indom, strbuf, sizeof(strbuf)), *inst, pmda->e_ordinal);
}
#endif
return 1;
}
}
}
pmda->e_ordinal = -1;
}
return 0;
}
char *
__pmLabelIdentString(int ident, int type, char *buf, size_t buflen)
{
char *p, id[32];
switch (type) {
case PM_LABEL_DOMAIN:
pmsprintf(buf, buflen, "Domain %u", ident);
break;
case PM_LABEL_INDOM:
case PM_LABEL_INSTANCES:
pmsprintf(buf, buflen, "InDom %s", pmInDomStr_r(ident, id, sizeof(id)));
break;
case PM_LABEL_CLUSTER:
pmIDStr_r(ident, id, sizeof(id));
p = rindex(id, '.');
*p = '\0';
pmsprintf(buf, buflen, "Cluster %s", id);
break;
case PM_LABEL_ITEM:
pmsprintf(buf, buflen, "PMID %s", pmIDStr_r(ident, id, sizeof(id)));
break;
case PM_LABEL_CONTEXT:
pmsprintf(buf, buflen, "Context");
break;
default:
buf[0] = '\0';
break;
}
return buf;
}
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
foo(FILE *f, char *fn, int i)
{
int sts;
char *tmp;
if ((sts = pmLookupText(pmidlist[i], PM_TEXT_ONELINE, &tmp)) < 0) {
fprintf(f, "%s: %s: pmLookupText oneline Error: %s\n", fn, namelist[i], pmErrStr(sts));
pthread_exit("botch");
}
fprintf(f, "%s: %s: %d", fn, namelist[i], (int)strlen(tmp));
free(tmp);
if ((sts = pmLookupText(pmidlist[i], PM_TEXT_HELP, &tmp)) < 0) {
fprintf(f, "\n%s: %s: pmLookupText help Error: %s\n", fn, namelist[i], pmErrStr(sts));
pthread_exit("botch");
}
fprintf(f, " & %d", (int)strlen(tmp));
free(tmp);
if (desclist[i].indom != PM_INDOM_NULL) {
char strbuf[20];
if ((sts = pmLookupInDomText(desclist[i].indom, PM_TEXT_ONELINE, &tmp)) < 0) {
fprintf(f, "\n%s: %s: pmLookupInDomText %s oneline Error: %s\n", fn, namelist[i], pmInDomStr_r(desclist[i].indom, strbuf, sizeof(strbuf)), pmErrStr(sts));
pthread_exit("botch");
}
fprintf(f, " %s: %d", pmInDomStr_r(desclist[i].indom, strbuf, sizeof(strbuf)), (int)strlen(tmp));
free(tmp);
if ((sts = pmLookupInDomText(desclist[i].indom, PM_TEXT_HELP, &tmp)) < 0) {
fprintf(f, "\n%s: %s: pmLookupInDomText %s help Error: %s\n", fn, namelist[i], pmInDomStr_r(desclist[i].indom, strbuf, sizeof(strbuf)), pmErrStr(sts));
pthread_exit("botch");
}
fprintf(f, " & %d", (int)strlen(tmp));
free(tmp);
}
fputc('\n', f);
}
/*
* State between here and __pmdaNextInst is a little strange
*
* for the classical method,
* - pmda->e_idp is set here (points into indomtab[]) and
* pmda->e_idp->it_indom is used in __pmdaNextInst
*
* for the cache method
* - pmda->e_idp is set here (points into last) which is also set
* up with the it_indom field (other fields in last are not used),
* and pmda->e_idp->it_indom in __pmdaNextInst
*
* In both cases, pmda->e_ordinal and pmda->e_singular are set here
* and updated in __pmdaNextInst.
*
* As in most other places, this is not thread-safe and we assume we
* call __pmdaStartInst and then repeatedly call __pmdaNextInst all
* for the same indom, before calling __pmdaStartInst again.
*
* If we could do this again, adding an indom argument to __pmdaNextInst
* would be a better design, but the API to __pmdaNextInst has escaped.
*/
void
__pmdaStartInst(pmInDom indom, pmdaExt *pmda)
{
int i;
pmda->e_ordinal = pmda->e_singular = -1;
if (indom == PM_INDOM_NULL) {
/* singular value */
pmda->e_singular = 0;
}
else {
if (pmdaCacheOp(indom, PMDA_CACHE_CHECK)) {
pmdaCacheOp(indom, PMDA_CACHE_WALK_REWIND);
last.it_indom = indom;
pmda->e_idp = &last;
pmda->e_ordinal = 0;
}
else {
for (i = 0; i < pmda->e_nindoms; i++) {
if (pmda->e_indoms[i].it_indom == indom) {
/* multiple values are possible */
pmda->e_idp = &pmda->e_indoms[i];
pmda->e_ordinal = 0;
break;
}
}
}
}
#ifdef PCP_DEBUG
if (pmDebug & DBG_TRACE_INDOM) {
char strbuf[20];
fprintf(stderr, "__pmdaStartInst(indom=%s) e_ordinal=%d\n",
pmInDomStr_r(indom, strbuf, sizeof(strbuf)), pmda->e_ordinal);
}
#endif
return;
}
void
pmiDump(void)
{
FILE *f = stderr;
fprintf(f, "pmiDump: context %ld of %d",
(long)(current - context_tab), ncontext);
if (current == NULL) {
fprintf(f, " Error: current context is not defined.\n");
return;
}
else {
fprintf(f, " archive: %s\n",
current->archive == NULL ? "<undefined>" : current->archive);
}
fprintf(f, " state: %d ", current->state);
switch (current->state) {
case CONTEXT_START:
fprintf(f, "(start)");
break;
case CONTEXT_ACTIVE:
fprintf(f, "(active)");
break;
case CONTEXT_END:
fprintf(f, "(end)");
break;
default:
fprintf(f, "(BAD)");
break;
}
fprintf(f, " hostname: %s timezone: %s\n",
current->hostname == NULL ? "<undefined>" : current->hostname,
current->timezone == NULL ? "<undefined>" : current->timezone);
if (current->nmetric == 0)
fprintf(f, " No metrics.\n");
else {
int m;
char strbuf[20];
for (m = 0; m < current->nmetric; m++) {
fprintf(f, " metric[%d] name=%s pmid=%s\n",
m, current->metric[m].name,
pmIDStr_r(current->metric[m].pmid, strbuf, sizeof(strbuf)));
__pmPrintDesc(f, ¤t->metric[m].desc);
}
}
if (current->nindom == 0)
fprintf(f, " No indoms.\n");
else {
int i;
char strbuf[20];
for (i = 0; i < current->nindom; i++) {
fprintf(f, " indom[%d] indom=%s",
i, pmInDomStr_r(current->indom[i].indom, strbuf, sizeof(strbuf)));
if (current->indom[i].ninstance == 0) {
fprintf(f, " No instances.\n");
}
else {
int j;
fputc('\n', f);
for (j = 0; j < current->indom[i].ninstance; j++) {
fprintf(f, " instance[%d] %s (%d)\n",
j, current->indom[i].name[j],
current->indom[i].inst[j]);
}
}
}
}
if (current->nhandle == 0)
fprintf(f, " No handles.\n");
else {
int h;
char strbuf[20];
for (h = 0; h < current->nhandle; h++) {
fprintf(f, " handle[%d] metric=%s (%s) instance=%d\n",
h, current->metric[current->handle[h].midx].name,
pmIDStr_r(current->metric[current->handle[h].midx].pmid, strbuf, sizeof(strbuf)),
current->handle[h].inst);
}
}
if (current->result == NULL)
fprintf(f, " No pmResult.\n");
else
__pmDumpResult(f, current->result);
}
/*
* 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);
}
}
