static void *
func1(void *arg)
{
int sts;
char *fn = "func1";
char **offspring;
int *status;
int i;
int j;
char *namelist[] = { "b", "a.three.foo", "d.f.fumble" };
pmID pmidlist[3];
pthread_barrier_wait(&barrier);
__pmDumpNameSpace(stdout, 1);
sts = pmGetChildrenStatus("", &offspring, &status);
if (sts >= 0) {
printf("%s: pmGetChildrenStatus -> %d\n", fn, sts);
for (i = 0; i < sts; i++) {
printf("[%d] %s %s\n", i, offspring[i], status[i] == PMNS_LEAF_STATUS ? "leaf" : "non-leaf");
}
free(offspring);
free(status);
}
else
printf("%s: pmGetChildrenStatus -> %s\n", fn, pmErrStr(sts));
for (i = 0; i < 5; i++) {
pthread_barrier_wait(&barrier);
sts = pmLookupName(sizeof(namelist)/sizeof(namelist[0]), namelist, pmidlist);
if (sts < 0)
printf("%s: pmGetChildrenStatus[%d] -> %s\n", fn, i, pmErrStr(sts));
else {
for (j = 0; j < sizeof(namelist)/sizeof(namelist[0]); j++) {
printf("%s: [%d] %s -> %s", fn, i, namelist[j], pmIDStr(pmidlist[j]));
if (pmidlist[j] == PM_ID_NULL)
printf("\n");
else {
char *name;
sts = pmNameID(pmidlist[j], &name);
if (sts < 0)
printf(": pmNameID -> %s\n", pmErrStr(sts));
else {
printf(" -> %s\n", name);
free(name);
}
}
}
}
pthread_barrier_wait(&barrier);
}
pthread_exit(NULL);
}
static void
foo(FILE *f, char *fn, int i, void *closure)
{
int sts;
int numnames;
int j;
int leaf;
pmID pmids[NMETRIC];
char **names;
char *name;
int *stsset;
char strbuf[20];
if ((sts = pmLookupName(NMETRIC-i, &namelist[i], pmids)) < 0) {
if (sts != PM_ERR_NONLEAF) {
fprintf(f, "%s: %s ...: pmLookupName Error: %s\n", fn, namelist[i], pmErrStr(sts));
pthread_exit("botch");
}
}
for (j = i; j < NMETRIC; j++) {
if (pmids[j-i] != pmidlist[j]) {
fprintf(f, "%s: %s: Botch: expecting %s", fn, namelist[j], pmIDStr_r(pmidlist[j], strbuf, sizeof(strbuf)));
fprintf(f, ", got %s\n", pmIDStr_r(pmids[j-i], strbuf, sizeof(strbuf)));
pthread_exit("botch");
}
}
fprintf(f, "%s: %s ... pmLookupName OK\n", fn, namelist[i]);
fprintf(f, "%s: %s", fn, namelist[i]);
if (pmidlist[i] != PM_ID_NULL) {
/* leaf node in PMNS */
if ((numnames = pmNameAll(pmidlist[i], &names)) < 0) {
fprintf(f, "\n%s: %s ...: pmNameAll Error: %s\n", fn, namelist[i], pmErrStr(numnames));
pthread_exit("botch");
}
for (j = 0; j < numnames; j++) {
if (strcmp(names[j], namelist[i]) == 0)
break;
}
if (j == numnames) {
fprintf(f, "\n%s: %s: Botch: expecting %s, got {", fn, pmIDStr_r(pmidlist[i], strbuf, sizeof(strbuf)), namelist[i]);
__pmPrintMetricNames(f, numnames, names, ",");
fprintf(f, "}\n");
pthread_exit("botch");
}
fprintf(f, " pmNameAll OK");
if ((sts = pmNameID(pmidlist[i], &name)) < 0) {
fprintf(f, "\n%s: %s ...: pmNameID Error: %s\n", fn, namelist[i], pmErrStr(sts));
pthread_exit("botch");
}
for (j = 0; j < numnames; j++) {
if (strcmp(name, names[j]) == 0)
break;
}
if (j == numnames) {
fprintf(f, "\n%s: %s: Botch: expecting one of {", fn, pmIDStr_r(pmidlist[i], strbuf, sizeof(strbuf)));
__pmPrintMetricNames(f, numnames, names, ",");
fprintf(f, "}, got %s\n", name);
pthread_exit("botch");
}
free(names);
free(name);
fprintf(f, " pmNameID OK");
}
else {
/* non-leaf node in PMNS */
int keep = 0;
if ((sts = pmGetChildrenStatus(namelist[i], &names, &stsset)) < 0) {
fprintf(f, "\n%s: %s ...: pmGetChildrenStatus Error: %s\n", fn, namelist[i], pmErrStr(sts));
pthread_exit("botch");
}
leaf = 0;
for (j = 0; j < sts; j++) {
if (stsset[j] == PMNS_LEAF_STATUS) leaf++;
}
PM_LOCK(chn_lock);
if (leaf_chn[i] == -1) {
leaf_chn[i] = leaf;
nonleaf_chn[i] = sts - leaf;
chn[i] = names;
keep = 1;
}
else {
if (leaf != leaf_chn[i] || sts - leaf != nonleaf_chn[i]) {
fprintf(f, "\n%s: %s: Botch: expecting %d leaf & %d non-leaf, got %d leaf & %d non-leaf\n", fn, namelist[i], leaf_chn[i], nonleaf_chn[i], leaf, sts - leaf);
pthread_exit("botch");
}
for (j = 0; j < sts; j++) {
if (strcmp(chn[i][j], names[j]) != 0) {
fprintf(f, "\n%s: %s: Botch: child[%d] expecting %s, got %s\n", fn, namelist[i], j, chn[i][j], names[j]);
PM_UNLOCK(chn_lock);
pthread_exit("botch");
}
}
}
if (keep == 0) {
free(names);
names = NULL; /* silence coverity */
}
free(stsset);
fprintf(f, " pmGetChildrenStatus OK");
if ((sts = pmGetChildren(namelist[i], &names)) < 0) {
fprintf(f, "\n%s: %s ...: pmGetChildren Error: %s\n", fn, namelist[i], pmErrStr(sts));
PM_UNLOCK(chn_lock);
pthread_exit("botch");
}
if (sts != leaf_chn[i] + nonleaf_chn[i]) {
fprintf(f, "\n%s: %s: Botch: expecting %d children, got %d\n", fn, namelist[i], leaf_chn[i] + nonleaf_chn[i], sts);
PM_UNLOCK(chn_lock);
pthread_exit("botch");
}
for (j = 0; j < sts; j++) {
if (strcmp(chn[i][j], names[j]) != 0) {
fprintf(f, "\n%s: %s: Botch: child[%d] expecting %s, got %s\n", fn, namelist[i], j, chn[i][j], names[j]);
PM_UNLOCK(chn_lock);
pthread_exit("botch");
}
}
PM_UNLOCK(chn_lock);
free(names);
fprintf(f, " pmGetChildren OK");
*((int *)closure) = 0;
if ((sts = pmTraversePMNS_r(namelist[i], dometric, closure)) < 0) {
fprintf(f, "\n%s: %s ...: pmTraversePMNS_r Error: %s\n", fn, namelist[i], pmErrStr(sts));
pthread_exit("botch");
}
if (sum_traverse[i] != *((int *)closure)) {
fprintf(f, "\n%s: %s: Botch: sum strlen(descendent names) expecting %d, got %d\n", fn, namelist[i], sum_traverse[i], *((int *)closure));
pthread_exit("botch");
}
fprintf(f, " pmTraversePMNS_r OK");
}
fputc('\n', f);
}
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);
}
