static int
check_timestamp(void)
{
if (current->result->timestamp.tv_sec < current->last_stamp.tv_sec ||
(current->result->timestamp.tv_sec == current->last_stamp.tv_sec &&
current->result->timestamp.tv_usec < current->last_stamp.tv_usec)) {
fprintf(stderr, "Fatal Error: timestamp ");
printstamp(stderr, ¤t->result->timestamp);
fprintf(stderr, " not greater than previous valid timestamp ");
printstamp(stderr, ¤t->last_stamp);
fputc('\n', stderr);
return PMI_ERR_BADTIMESTAMP;
}
return 0;
}
int
pmiWrite(int sec, int usec)
{
int sts;
if (current == NULL)
return PM_ERR_NOCONTEXT;
if (current->result == NULL)
return current->last_sts = PMI_ERR_NODATA;
if (sec < 0) {
__pmtimevalNow(¤t->result->timestamp);
}
else {
current->result->timestamp.tv_sec = sec;
current->result->timestamp.tv_usec = usec;
}
if (current->result->timestamp.tv_sec < current->last_stamp.tv_sec ||
(current->result->timestamp.tv_sec == current->last_stamp.tv_sec &&
current->result->timestamp.tv_usec < current->last_stamp.tv_usec)) {
fprintf(stderr, "Fatal Error: timestamp ");
printstamp(stderr, ¤t->result->timestamp);
fprintf(stderr, " not greater than previous valid timestamp ");
printstamp(stderr, ¤t->last_stamp);
fputc('\n', stderr);
sts = PMI_ERR_BADTIMESTAMP;
}
else {
sts = _pmi_put_result(current, current->result);
current->last_stamp = current->result->timestamp;
}
pmFreeResult(current->result);
current->result = NULL;
return current->last_sts = sts;
}
int
main(int argc, char **argv)
{
int c;
int sts;
int e_sts = 0;
int errflag = 0;
int ahtype = 0;
int verbose = 0;
int quick = 0;
char *host = NULL; /* pander to gcc */
pmResult *result;
pmResult *prev = NULL;
struct timeval start = { 0,0 };
struct timeval end;
int tzh;
off_t trunc_size = 0;
__pmSetProgname(argv[0]);
while ((c = getopt(argc, argv, "a:D:t:qv?")) != EOF) {
switch (c) {
case 'a': /* archive name */
if (ahtype != 0) {
fprintf(stderr, "%s: at most one of -a and/or -h allowed\n", pmProgname);
errflag++;
}
ahtype = PM_CONTEXT_ARCHIVE;
host = optarg;
break;
#ifdef PCP_DEBUG
case 'D': /* debug flag */
sts = __pmParseDebug(optarg);
if (sts < 0) {
fprintf(stderr, "%s: unrecognized debug flag specification (%s)\n",
pmProgname, optarg);
errflag++;
}
else
pmDebug |= sts;
break;
#endif
case 't': /* truncate */
trunc_size = atol(optarg);
break;
case 'q': /* quick */
quick = 1;
break;
case 'v': /* verbose */
verbose++;
break;
case '?':
default:
errflag++;
break;
}
}
if (errflag || optind < argc) {
fprintf(stderr,
"Usage: %s options ...\n\
\n\
Options\n\
-a archive metrics source is an archive log\n\
-t size truncate archive to size bytes\n\
-q quick (read last 3 records, not the whole archive)\n\
-v verbose\n",
pmProgname);
exit(1);
}
if (ahtype != PM_CONTEXT_ARCHIVE) {
fprintf(stderr, "%s: -a is not optional!\n", pmProgname);
exit(1);
}
/* truncate if -t specified, _before_ opening archive */
if (trunc_size != 0) {
if (access(host, W_OK) == 0) {
if (truncate(host, trunc_size) != 0) {
fprintf(stderr, "%s: file %s exists, but cannot truncate\n",
pmProgname, host);
exit(1);
}
}
else {
char path[MAXPATHLEN];
sprintf(path, "%s.0", host);
if (access(path, W_OK) == 0) {
if (truncate(path, trunc_size) != 0) {
fprintf(stderr, "%s: file %s exists, but cannot truncate\n",
pmProgname, path);
exit(1);
}
}
else {
fprintf(stderr, "%s: cannot find writeable %s or %s\n",
pmProgname, host, path);
exit(1);
}
}
}
if ((sts = pmNewContext(ahtype, host)) < 0) {
fprintf(stderr, "%s: Cannot open archive \"%s\": %s\n",
pmProgname, host, pmErrStr(sts));
exit(1);
}
/* force -z (timezone of archive */
if ((tzh = pmNewContextZone()) < 0) {
fprintf(stderr, "%s: Cannot set context timezone: %s\n",
pmProgname, pmErrStr(tzh));
exit(1);
}
sts = pmGetArchiveEnd(&end);
if (sts < 0) {
printf("pmGetArchiveEnd: %s\n", pmErrStr(sts));
}
else {
if (verbose) {
printf("pmGetArchiveEnd time: ");
printstamp(&end);
printf("\n");
}
}
sts = pmSetMode(PM_MODE_BACK, &end, 0);
if (sts < 0) {
printf("pmSetMode PM_MODE_BACK: %s\n", pmErrStr(sts));
exit(1);
}
sts = pmFetchArchive(&result);
if (sts < 0) {
printf("pmFetchArchive: %s\n", pmErrStr(sts));
e_sts = 1;
}
else {
if (verbose) {
printf("last result time (direct): ");
printstamp(&result->timestamp);
printf("\n");
}
if (result->timestamp.tv_sec != end.tv_sec ||
result->timestamp.tv_usec != end.tv_usec) {
printf("Mismatch: end=");
printstamp(&end);
printf(" direct=");
printstamp(&result->timestamp);
printf("\n");
e_sts = 1;
}
start.tv_sec = result->timestamp.tv_sec;
start.tv_usec = result->timestamp.tv_usec;
pmFreeResult(result);
}
if (quick && e_sts == 0) {
int i;
for (i = 0; i < 2; i++) {
sts = pmFetchArchive(&result);
if (sts >= 0) {
start.tv_sec = result->timestamp.tv_sec;
start.tv_usec = result->timestamp.tv_usec;
pmFreeResult(result);
}
}
}
else {
/* start from the epoch and move forward */
start.tv_sec = 0;
start.tv_usec = 0;
}
sts = pmSetMode(PM_MODE_FORW, &start, 0);
if (sts < 0) {
printf("pmSetMode PM_MODE_FORW: %s\n", pmErrStr(sts));
exit(1);
}
while ((sts = pmFetchArchive(&result)) >= 0) {
if (prev != NULL)
pmFreeResult(prev);
prev = result;
}
if (verbose) printf("pmFetchArchive: %s\n", pmErrStr(sts));
if (prev == NULL) {
printf("no results!\n");
}
else {
if (verbose) {
printf("last result time (serial): ");
printstamp(&prev->timestamp);
printf("\n");
}
if (prev->timestamp.tv_sec != end.tv_sec ||
prev->timestamp.tv_usec != end.tv_usec) {
printf("Mismatch: end=");
printstamp(&end);
printf(" serial=");
printstamp(&prev->timestamp);
printf("\n");
e_sts = 1;
}
pmFreeResult(prev);
}
exit(e_sts);
}
int
main(int argc, char **argv)
{
int c;
int sts;
int errflag = 0;
struct timeval delta = { 2, 500000 };
struct timeval now;
__pmSetProgname(argv[0]);
while ((c = getopt(argc, argv, "D:?")) != EOF) {
switch (c) {
case 'D': /* debug flag */
sts = __pmParseDebug(optarg);
if (sts < 0) {
fprintf(stderr, "%s: unrecognized debug flag specification (%s)\n",
pmProgname, optarg);
errflag++;
}
else
pmDebug |= sts;
break;
case '?':
default:
errflag++;
break;
}
}
if (errflag) {
fprintf(stderr,
"Usage: %s options ...\n\
\n\
Options\n\
-D debug standard PCP debug flag\n",
pmProgname);
exit(1);
}
__pmAFblock();
gettimeofday(&start, NULL);
reg[0] = __pmAFregister(&delta, NULL, onevent);
delta.tv_sec = 1;
reg[1] = __pmAFregister(&delta, NULL, onevent);
delta.tv_sec = 0;
delta.tv_usec = 0;
reg[2] = __pmAFregister(&delta, NULL, onevent);
delta.tv_sec = 60; /* will never fire */
reg[3] = __pmAFregister(&delta, NULL, onevent);
__pmAFunblock();
for ( ; ; ) {
fflush(stderr);
pause();
if (pmDebug & DBG_TRACE_AF) {
gettimeofday(&now, NULL);
fprintf(stderr, "returned from pause(): ");
printstamp(&now);
fputc('\n', stderr);
}
}
}
void
onevent(int afid, void *data)
{
struct timeval now;
static int delay = -3;
int evnum;
double elapsed;
struct timeval sec = { 0, 0 };
gettimeofday(&now, NULL);
if (pmDebug & DBG_TRACE_AF) {
fprintf(stderr, "onevent(%d, " PRINTF_P_PFX "%p) called: ", afid, data);
printstamp(&now);
fputc('\n', stderr);
}
elapsed = now.tv_sec - start.tv_sec + (double)(now.tv_usec - start.tv_usec) / 1000000.0;
if (afid == reg[2])
printf("event %d callback\n", afid);
else {
if (afid == reg[0])
evnum = (int)(elapsed / 2.5);
else
evnum = (int)(elapsed / 1.5);
/* evnum not reliable for small elapsed intervals */
if (evnum >= 3)
printf("event %d callback #%d\n", afid, evnum);
else
printf("event %d callback #?\n", afid);
}
if (delay > 6) {
/* only report the unexpected */
if (__pmAFunregister(reg[0]) < 0)
printf("unregister %d failed\n", reg[0]);
if (__pmAFunregister(reg[1]) == 0)
printf("unregister %d success\n", reg[1]);
if (__pmAFunregister(reg[2]) == 0)
printf("unregister %d success\n", reg[2]);
if (__pmAFunregister(reg[3]) < 0)
printf("unregister %d failed\n", reg[0]);
exit(0);
}
if (delay > 0) {
/*
* was sginap(delay * CLK_TCK) ... usleep() for
* delay*CLK_TCK*10^6/CLK_TCK microseconds so "delay" sec
*/
sec.tv_sec = delay;
__pmtimevalSleep(sec);
}
delay++;
if (pmDebug & DBG_TRACE_AF) {
gettimeofday(&now, NULL);
fprintf(stderr, "onevent done: ");
printstamp(&now);
fputc('\n', stderr);
}
fflush(stderr);
fflush(stdout);
}
