void
__pmConfig(__pmConfigCallback formatter)
{
/*
* Scan ${PCP_CONF-$PCP_DIR/etc/pcp.conf} and put all PCP config
* variables found therein into the environment.
*/
FILE *fp;
char confpath[32];
char dir[MAXPATHLEN];
char var[MAXPATHLEN];
char *prefix;
char *conf;
char *val;
char *p;
PM_INIT_LOCKS();
PM_LOCK(__pmLock_libpcp);
prefix = getenv("PCP_DIR");
if ((conf = getenv("PCP_CONF")) == NULL) {
strncpy(confpath, "/etc/pcp.conf", sizeof(confpath));
if (prefix == NULL)
conf = __pmNativePath(confpath);
else {
snprintf(dir, sizeof(dir),
"%s%s", prefix, __pmNativePath(confpath));
conf = dir;
}
}
if (access((const char *)conf, R_OK) < 0 ||
(fp = fopen(conf, "r")) == (FILE *)NULL) {
char errmsg[PM_MAXERRMSGLEN];
pmprintf("FATAL PCP ERROR: could not open config file \"%s\" : %s\n",
conf, osstrerror_r(errmsg, sizeof(errmsg)));
pmprintf("You may need to set PCP_CONF or PCP_DIR in your environment.\n");
pmflush();
PM_UNLOCK(__pmLock_libpcp);
exit(1);
}
while (fgets(var, sizeof(var), fp) != NULL) {
if (var[0] == '#' || (p = strchr(var, '=')) == NULL)
continue;
*p = '\0';
val = p+1;
if ((p = strrchr(val, '\n')) != NULL)
*p = '\0';
if ((p = getenv(var)) != NULL)
val = p;
else
formatter(var, prefix, val);
if (pmDebug & DBG_TRACE_CONFIG)
fprintf(stderr, "pmGetConfig: (init) %s=%s\n", var, val);
}
fclose(fp);
PM_UNLOCK(__pmLock_libpcp);
}
void
store(char const* name, char const* inst)
{
char buf[128];
sprintf(buf, "pmstore %s %s > /dev/null\n", name, inst);
cout << name << ' ' << inst << endl;
if (system(buf) < 0) {
pmprintf("%s: cannot run system(%s)\n", pmProgname, buf);
pmflush();
exit(1);
}
}
/*
* use pmprintf for fatal messages as we're usually run from
* pmLoadNameSpace() in libpcp
*/
static void
err(char *msg)
{
fflush(stdout);
if (currfile != NULL) {
if (currfile->lineno > 0)
pmprintf("pmcpp: %s[%d]: %s", currfile->fname, currfile->lineno, ibuf);
else
pmprintf("pmcpp: %s:\n", currfile->fname);
}
pmprintf("pmcpp: Error: %s\n", msg);
pmflush();
exit(1);
}
void PmChart::quit()
{
// End any processes we may have started and close any open dialogs
if (my.dialogsSetup) {
my.info->reject();
}
if (pmtime)
pmtime->quit();
#ifdef HAVE_UNSETENV
unsetenv("PCP_STDERR");
#else
putenv("PCP_STDERR=");
#endif
pmflush();
}
/*
* PMAPI context creation and initial command line option handling.
*/
static int
setup_context(pmOptions *opts)
{
char *source;
int sts, ctx;
if (opts->context == PM_CONTEXT_ARCHIVE)
source = opts->archives[0];
else 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 = ctx = pmNewContext(opts->context, source)) < 0)
{
if (opts->context == PM_CONTEXT_HOST)
pmprintf(
"%s: Cannot connect to pmcd on host \"%s\": %s\n",
pmProgname, source, pmErrStr(sts));
else if (opts->context == PM_CONTEXT_LOCAL)
pmprintf(
"%s: Cannot make standalone connection on localhost: %s\n",
pmProgname, pmErrStr(sts));
else
pmprintf(
"%s: Cannot open archive \"%s\": %s\n",
pmProgname, source, pmErrStr(sts));
}
else if ((sts = pmGetContextOptions(ctx, opts)) == 0)
sts = setup_origin(opts);
if (sts < 0)
{
pmflush();
cleanstop(1);
}
return ctx;
}
/* Register an anonymous metric */
int
__pmRegisterAnon(const char *name, int type)
{
char *msg;
char buf[21]; /* anon(PM_TYPE_XXXXXX) */
PM_FAULT_CHECK(PM_FAULT_PMAPI);
switch (type) {
case PM_TYPE_32:
snprintf(buf, sizeof(buf), "anon(PM_TYPE_32)");
break;
case PM_TYPE_U32:
snprintf(buf, sizeof(buf), "anon(PM_TYPE_U32)");
break;
case PM_TYPE_64:
snprintf(buf, sizeof(buf), "anon(PM_TYPE_64)");
break;
case PM_TYPE_U64:
snprintf(buf, sizeof(buf), "anon(PM_TYPE_U64)");
break;
case PM_TYPE_FLOAT:
snprintf(buf, sizeof(buf), "anon(PM_TYPE_FLOAT)");
break;
case PM_TYPE_DOUBLE:
snprintf(buf, sizeof(buf), "anon(PM_TYPE_DOUBLE)");
break;
default:
return PM_ERR_TYPE;
}
if ((msg = pmRegisterDerived(name, buf)) != NULL) {
pmprintf("__pmRegisterAnon(%s, %d): @ \"%s\" Error: %s\n", name, type, msg, pmDerivedErrStr());
pmflush();
return PM_ERR_GENERIC;
}
return 0;
}
int main(int argc, char **argv)
{
int autoport = 0;
QApplication a(argc, argv);
setupEnvironment();
/* -a/-h ignored, back-compat for time control from libpcp_gui */
opts.short_options = "ahD:p:V?";
opts.long_options = longopts;
(void)pmGetOptions(argc, argv, &opts);
if (opts.errors || opts.optind != argc) {
pmUsageMessage(&opts);
exit(1);
}
if (!opts.guiport) {
char *endnum, *envstr;
autoport = 1;
if ((envstr = getenv("PMTIME_PORT")) == NULL) {
opts.guiport = PmTime::BasePort;
} else {
opts.guiport = strtol(envstr, &endnum, 0);
if (*endnum != '\0' || opts.guiport < 0) {
pmprintf(
"%s: PMTIME_PORT must be a numeric port number (not %s)\n",
pmProgname, envstr);
pmflush();
exit(1);
}
}
}
console = new Console;
TimeLord tl(&a);
do {
if (tl.listen(QHostAddress::LocalHost, opts.guiport))
break;
opts.guiport++;
} while (autoport && (opts.guiport >= 0));
if (!opts.guiport || tl.isListening() == false) {
if (!autoport)
pmprintf("%s: cannot find an available port\n", pmProgname);
else
pmprintf("%s: cannot connect to requested port (%d)\n",
pmProgname, opts.guiport);
pmflush();
exit(1);
} else if (autoport) { /* write to stdout for client */
char name[32];
int c = snprintf(name, sizeof(name), "port=%u\n", opts.guiport);
if (write(fileno(stdout), name, c + 1) < 0) {
if (errno != EPIPE) {
pmprintf("%s: cannot write port for client: %s\n",
pmProgname, strerror(errno));
pmflush();
}
exit(1);
}
}
PmTimeLive hc;
PmTimeArch ac;
tl.setContext(&hc, &ac);
hc.init();
if (!pmDebug) hc.disableConsole();
else hc.popup(1);
ac.init();
if (!pmDebug) ac.disableConsole();
else ac.popup(1);
a.exec();
return 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)
{
int c;
int sts;
int samples;
int pauseFlag = 0;
int lines = 0;
char *source;
const char *host;
char timebuf[26]; /* for pmCtime result */
setlinebuf(stdout);
while ((c = pmGetOptions(argc, argv, &opts)) != EOF) {
switch (c) {
case 'P':
pauseFlag++;
break;
default:
opts.errors++;
break;
}
}
if (pauseFlag && opts.context != PM_CONTEXT_ARCHIVE) {
pmprintf("%s: pause can only be used with archives\n", pmGetProgname());
opts.errors++;
}
if (opts.errors || opts.optind < argc - 1) {
pmUsageMessage(&opts);
exit(1);
}
if (opts.context == PM_CONTEXT_ARCHIVE) {
source = opts.archives[0];
} else if (opts.context == PM_CONTEXT_HOST) {
source = opts.hosts[0];
} else {
opts.context = PM_CONTEXT_HOST;
source = "local:";
}
sts = pmCreateFetchGroup(& pmfg, opts.context, source);
if (sts < 0) {
if (opts.context == PM_CONTEXT_HOST)
fprintf(stderr, "%s: Cannot connect to PMCD on host \"%s\": %s\n",
pmGetProgname(), source, pmErrStr(sts));
else
fprintf(stderr, "%s: Cannot open archive \"%s\": %s\n",
pmGetProgname(), source, pmErrStr(sts));
exit(1);
}
c = pmGetFetchGroupContext(pmfg);
/* complete TZ and time window option (origin) setup */
if (pmGetContextOptions(c, &opts)) {
pmflush();
exit(1);
}
host = pmGetContextHostName(c);
/* set a default sampling interval if none has been requested */
if (opts.interval.tv_sec == 0 && opts.interval.tv_usec == 0)
opts.interval.tv_sec = 5;
if (opts.context == PM_CONTEXT_ARCHIVE) {
if ((sts = pmSetMode(PM_MODE_INTERP, &opts.start, (int)(opts.interval.tv_sec*1000 + opts.interval.tv_usec/1000))) < 0) {
fprintf(stderr, "%s: pmSetMode failed: %s\n",
pmGetProgname(), pmErrStr(sts));
exit(1);
}
}
if (opts.context == PM_CONTEXT_ARCHIVE)
get_sample(); /* fetch the separate early ncpu record */
get_sample(); /* fetch other rate metrics */
/* set sampling loop termination via the command line options */
samples = opts.samples ? opts.samples : -1;
while (samples == -1 || samples-- > 0) {
if (lines % 15 == 0) {
time_t now = info.timestamp.tv_sec;
if (opts.context == PM_CONTEXT_ARCHIVE)
printf("Archive: %s, ", opts.archives[0]);
printf("Host: %s, %d cpu(s), %s",
host, info.ncpu.l,
pmCtime(&now, timebuf));
/* - report format
CPU Busy Busy Free Mem Disk Load Average
Util CPU Util (Mbytes) IOPS 1 Min 15 Min
X.XXX XXX X.XXX XXXXX.XXX XXXXXX XXXX.XX XXXX.XX
*/
printf(" CPU");
if (info.ncpu.l > 1)
printf(" Busy Busy");
printf(" Free Mem Disk Load Average\n");
printf(" Util");
if (info.ncpu.l > 1)
printf(" CPU Util");
printf(" (Mbytes) IOPS 1 Min 15 Min\n");
}
if (opts.context != PM_CONTEXT_ARCHIVE || pauseFlag)
__pmtimevalSleep(opts.interval);
get_sample();
printf("%5.2f", info.cpu_util);
if (info.ncpu.l > 1)
printf(" %3d %5.2f", info.peak_cpu, info.peak_cpu_util);
printf(" %9.3f", info.freemem.d);
printf(" %6d", info.dkiops.l);
printf(" %7.2f %7.2f\n", info.load1.d, info.load15.d);
lines++;
}
exit(0);
}
int
__pmConnectLocal(__pmHashCtl *attrs)
{
int i;
__pmDSO *dp;
char pathbuf[MAXPATHLEN];
const char *path;
#if defined(HAVE_DLOPEN)
unsigned int challenge;
void (*initp)(pmdaInterface *);
#ifdef HAVE_ATEXIT
static int atexit_installed = 0;
#endif
#endif
if (numdso == -1) {
int sts;
sts = build_dsotab();
if (sts < 0) return sts;
}
for (i = 0; i < numdso; i++) {
dp = &dsotab[i];
if (dp->domain == -1 || dp->handle != NULL)
continue;
/*
* __pmLocalPMDA() means the path to the DSO may be something
* other than relative to $PCP_PMDAS_DIR ... need to try both
* options and also with and without DSO_SUFFIX (so, dll, etc)
*/
snprintf(pathbuf, sizeof(pathbuf), "%s%c%s",
pmGetConfig("PCP_PMDAS_DIR"), __pmPathSeparator(), dp->name);
if ((path = __pmFindPMDA(pathbuf)) == NULL) {
snprintf(pathbuf, sizeof(pathbuf), "%s%c%s.%s",
pmGetConfig("PCP_PMDAS_DIR"), __pmPathSeparator(), dp->name, DSO_SUFFIX);
if ((path = __pmFindPMDA(pathbuf)) == NULL) {
if ((path = __pmFindPMDA(dp->name)) == NULL) {
snprintf(pathbuf, sizeof(pathbuf), "%s.%s", dp->name, DSO_SUFFIX);
if ((path = __pmFindPMDA(pathbuf)) == NULL) {
pmprintf("__pmConnectLocal: Warning: cannot find DSO at \"%s\" or \"%s\"\n",
pathbuf, dp->name);
pmflush();
dp->domain = -1;
dp->handle = NULL;
continue;
}
}
}
}
#if defined(HAVE_DLOPEN)
dp->handle = dlopen(path, RTLD_NOW);
if (dp->handle == NULL) {
pmprintf("__pmConnectLocal: Warning: error attaching DSO "
"\"%s\"\n%s\n\n", path, dlerror());
pmflush();
dp->domain = -1;
}
#else /* ! HAVE_DLOPEN */
dp->handle = NULL;
pmprintf("__pmConnectLocal: Warning: error attaching DSO \"%s\"\n",
path);
pmprintf("No dynamic DSO/DLL support on this platform\n\n");
pmflush();
dp->domain = -1;
#endif
if (dp->handle == NULL)
continue;
#if defined(HAVE_DLOPEN)
/*
* rest of this only makes sense if the dlopen() worked
*/
if (dp->init == NULL)
initp = NULL;
else
initp = (void (*)(pmdaInterface *))dlsym(dp->handle, dp->init);
if (initp == NULL) {
pmprintf("__pmConnectLocal: Warning: couldn't find init function "
"\"%s\" in DSO \"%s\"\n", dp->init, path);
pmflush();
dlclose(dp->handle);
dp->domain = -1;
continue;
}
/*
* Pass in the expected domain id.
* The PMDA initialization routine can (a) ignore it, (b) check it
* is the expected value, or (c) self-adapt.
*/
dp->dispatch.domain = dp->domain;
/*
* the PMDA interface / PMAPI version discovery as a "challenge" ...
* for pmda_interface it is all the bits being set,
* for pmapi_version it is the complement of the one you are using now
*/
challenge = 0xff;
dp->dispatch.comm.pmda_interface = challenge;
dp->dispatch.comm.pmapi_version = ~PMAPI_VERSION;
dp->dispatch.comm.flags = 0;
dp->dispatch.status = 0;
(*initp)(&dp->dispatch);
if (dp->dispatch.status != 0) {
/* initialization failed for some reason */
char errmsg[PM_MAXERRMSGLEN];
pmprintf("__pmConnectLocal: Warning: initialization "
"routine \"%s\" failed in DSO \"%s\": %s\n",
dp->init, path, pmErrStr_r(dp->dispatch.status, errmsg, sizeof(errmsg)));
pmflush();
dlclose(dp->handle);
dp->domain = -1;
}
else {
if (dp->dispatch.comm.pmda_interface < PMDA_INTERFACE_2 ||
dp->dispatch.comm.pmda_interface > PMDA_INTERFACE_LATEST) {
pmprintf("__pmConnectLocal: Error: Unknown PMDA interface "
"version %d in \"%s\" DSO\n",
dp->dispatch.comm.pmda_interface, path);
pmflush();
dlclose(dp->handle);
dp->domain = -1;
}
else if (dp->dispatch.comm.pmapi_version != PMAPI_VERSION_2) {
pmprintf("__pmConnectLocal: Error: Unknown PMAPI version %d "
"in \"%s\" DSO\n",
dp->dispatch.comm.pmapi_version, path);
pmflush();
dlclose(dp->handle);
dp->domain = -1;
}
else if (dp->dispatch.comm.pmda_interface >= PMDA_INTERFACE_6 &&
(dp->dispatch.comm.flags & PDU_FLAG_AUTH) != 0) {
/* Agent wants to know about connection attributes */
build_dsoattrs(&dp->dispatch, attrs);
}
}
#ifdef HAVE_ATEXIT
PM_INIT_LOCKS();
PM_LOCK(__pmLock_libpcp);
if (dp->dispatch.comm.pmda_interface >= PMDA_INTERFACE_5 &&
atexit_installed == 0) {
/* install end of local context handler */
atexit(EndLocalContext);
atexit_installed = 1;
}
PM_UNLOCK(__pmLock_libpcp);
#endif
#endif /* HAVE_DLOPEN */
}
return 0;
}
int
main(int argc, char **argv)
{
int c;
int sts;
int samples;
int pauseFlag = 0;
int lines = 0;
char *source;
const char *host;
info_t info; /* values to report each sample */
char timebuf[26]; /* for pmCtime result */
setlinebuf(stdout);
while ((c = pmGetOptions(argc, argv, &opts)) != EOF) {
switch (c) {
case 'P':
pauseFlag++;
break;
default:
opts.errors++;
break;
}
}
if (pauseFlag && opts.context != PM_CONTEXT_ARCHIVE) {
pmprintf("%s: pause can only be used with archives\n", pmProgname);
opts.errors++;
}
if (opts.errors || opts.optind < argc - 1) {
pmUsageMessage(&opts);
exit(1);
}
if (opts.context == PM_CONTEXT_ARCHIVE) {
source = opts.archives[0];
} else if (opts.context == PM_CONTEXT_HOST) {
source = opts.hosts[0];
} else {
opts.context = PM_CONTEXT_HOST;
source = "local:";
}
if ((sts = c = pmNewContext(opts.context, source)) < 0) {
if (opts.context == PM_CONTEXT_HOST)
fprintf(stderr, "%s: Cannot connect to PMCD on host \"%s\": %s\n",
pmProgname, source, pmErrStr(sts));
else
fprintf(stderr, "%s: Cannot open archive \"%s\": %s\n",
pmProgname, source, pmErrStr(sts));
exit(1);
}
/* complete TZ and time window option (origin) setup */
if (pmGetContextOptions(c, &opts)) {
pmflush();
exit(1);
}
host = pmGetContextHostName(c);
ncpu = get_ncpu();
if ((opts.context == PM_CONTEXT_ARCHIVE) &&
(opts.start.tv_sec != 0 || opts.start.tv_usec != 0)) {
if ((sts = pmSetMode(PM_MODE_FORW, &opts.start, 0)) < 0) {
fprintf(stderr, "%s: pmSetMode failed: %s\n",
pmProgname, pmErrStr(sts));
exit(1);
}
}
get_sample(&info);
/* set a default sampling interval if none has been requested */
if (opts.interval.tv_sec == 0 && opts.interval.tv_usec == 0)
opts.interval.tv_sec = 5;
/* set sampling loop termination via the command line options */
samples = opts.samples ? opts.samples : -1;
while (samples == -1 || samples-- > 0) {
if (lines % 15 == 0) {
if (opts.context == PM_CONTEXT_ARCHIVE)
printf("Archive: %s, ", opts.archives[0]);
printf("Host: %s, %d cpu(s), %s",
host, ncpu,
pmCtime((const time_t *)&info.timestamp.tv_sec, timebuf));
/* - report format
CPU Busy Busy Free Mem Disk Load Average
Util CPU Util (Mbytes) IOPS 1 Min 15 Min
X.XXX XXX X.XXX XXXXX.XXX XXXXXX XXXX.XX XXXX.XX
*/
printf(" CPU");
if (ncpu > 1)
printf(" Busy Busy");
printf(" Free Mem Disk Load Average\n");
printf(" Util");
if (ncpu > 1)
printf(" CPU Util");
printf(" (Mbytes) IOPS 1 Min 15 Min\n");
}
if (opts.context != PM_CONTEXT_ARCHIVE || pauseFlag)
__pmtimevalSleep(opts.interval);
get_sample(&info);
printf("%5.2f", info.cpu_util);
if (ncpu > 1)
printf(" %3d %5.2f", info.peak_cpu, info.peak_cpu_util);
printf(" %9.3f", info.freemem);
printf(" %6d", info.dkiops);
printf(" %7.2f %7.2f\n", info.load1, info.load15);
lines++;
}
exit(0);
}
static void
onalarm(int dummy)
{
struct timeval now;
struct timeval tmp;
struct timeval interval;
qelt *qp;
if (!block)
AFhold();
#ifdef PCP_DEBUG
if (pmDebug & DBG_TRACE_AF) {
__pmtimevalNow(&now);
__pmPrintStamp(stderr, &now);
fprintf(stderr, " AFonalarm(%d)\n", dummy);
}
#endif
if (root != NULL) {
/* something to do ... */
while (root != NULL) {
/* compute difference between scheduled time and now */
__pmtimevalNow(&now);
tmp = root->q_when;
tsub(&tmp, &now);
if (tmp.tv_sec == 0 && tmp.tv_usec <= 10000) {
/*
* within one 10msec tick, the time has passed for this one,
* execute the callback and reschedule
*/
qp = root;
root = root->q_next;
#ifdef PCP_DEBUG
if (pmDebug & DBG_TRACE_AF) {
__pmPrintStamp(stderr, &now);
fprintf(stderr, " AFcallback " PRINTF_P_PFX "%p(%d, " PRINTF_P_PFX "%p)\n",
qp->q_func, qp->q_afid, qp->q_data);
}
#endif
qp->q_func(qp->q_afid, qp->q_data);
if (qp->q_delta.tv_sec == 0 && qp->q_delta.tv_usec == 0) {
/*
* if delta is zero, this is a single-shot event,
* so do not reschedule it
*/
free(qp);
}
else {
/*
* avoid falling too far behind
* if the scheduled time is more than q_delta in the
* past we will never catch up ... better to skip some
* events to catch up ...
*
* <------------ next q_when range ----------------->
*
* cannot catchup | may catchup | on schedule
* | |
* --------------------|---------------|------------> time
* | |
* | +-- now
* +-- now - q_delta
*/
__pmtimevalNow(&now);
for ( ; ; ) {
tadd(&qp->q_when, &qp->q_delta);
tmp = qp->q_when;
tsub_real(&tmp, &now);
tadd(&tmp, &qp->q_delta);
if (tmp.tv_sec >= 0)
break;
#ifdef PCP_DEBUG
if (pmDebug & DBG_TRACE_AF) {
__pmPrintStamp(stderr, &now);
fprintf(stderr, " AFcallback event %d too slow, skip callback for ", qp->q_afid);
__pmPrintStamp(stderr, &qp->q_when);
fputc('\n', stderr);
}
#endif
}
enqueue(qp);
}
}
else
/*
* head of the queue (and hence all others) are too far in
* the future ... done for this time
*/
break;
}
if (root == NULL) {
pmprintf("Warning: AF event queue is empty, nothing more will be scheduled\n");
pmflush();
}
else {
/* set itimer for head of queue */
interval = root->q_when;
__pmtimevalNow(&now);
tsub(&interval, &now);
if (interval.tv_sec == 0 && interval.tv_usec < MIN_ITIMER_USEC)
/* use minimal delay (platform dependent) */
interval.tv_usec = MIN_ITIMER_USEC;
#ifdef PCP_DEBUG
if (pmDebug & DBG_TRACE_AF) {
__pmPrintStamp(stderr, &now);
fprintf(stderr, " AFsetitimer for delta ");
printdelta(stderr, &interval);
fputc('\n', stderr);
}
#endif
AFsetitimer(&interval);
}
}
if (!block) {
AFrearm();
AFrelse();
}
}
int
main(int argc, char* argv[])
{
int sts = 0;
int c;
char buf[MAXHOSTNAMELEN];
QString source;
pmProgname = basename(argv[0]);
while ((c = getopt(argc, argv, "D:?")) != EOF) {
switch (c) {
case 'D':
sts = __pmParseDebug(optarg);
if (sts < 0) {
pmprintf("%s: unrecognized debug flag specification (%s)\n",
pmProgname, optarg);
sts = 1;
}
else {
pmDebug |= sts;
sts = 0;
}
break;
case '?':
default:
sts = 1;
break;
}
}
if (sts) {
pmprintf("Usage: %s\n", pmProgname);
pmflush();
exit(1);
/*NOTREACHED*/
}
(void)gethostname(buf, MAXHOSTNAMELEN);
buf[MAXHOSTNAMELEN-1] = '\0';
source = buf;
fprintf(stderr,"*** Compare metric descriptor with pminfo output ***\n");
QmcSource *src = QmcSource::getSource(PM_CONTEXT_HOST, source, false);
if (src->status() < 0) {
pmprintf("%s: Error: Unable to create context to \"%s\": %s\n",
pmProgname, buf, pmErrStr(src->status()));
pmflush();
return 1;
}
/* Linux hinv.ncpu PMID: 60.0.32 */
pmID hinv_ncpu = pmid_build(60, 0, 32);
QmcDesc hinv_ncpu_pmc(hinv_ncpu);
pmDesc hinv_ncpu_desc = hinv_ncpu_pmc.desc();
if (hinv_ncpu_pmc.status() < 0) {
pmprintf("\n%s: Error: hinv.ncpu: %s\n",
pmProgname, pmErrStr(hinv_ncpu_pmc.status()));
pmflush();
sts = 1;
}
printf("hinv.ncpu\n");
__pmPrintDesc(stdout, &hinv_ncpu_desc);
fflush(stdout);
fflush(stderr);
if (system("pminfo -d hinv.ncpu") < 0) {
pmprintf("%s: Error: Unable to run pminfo\n", pmProgname);
pmflush();
sts = 1;
}
fflush(stdout);
fflush(stderr);
fprintf(stderr, "\n*** Fetch a bad descriptor ***\n");
pmID bad = pmid_build(42,42,42);
QmcDesc bad_pmc(bad);
if (bad_pmc.status() < 0) {
pmprintf("%s: Error: Bogus metric: %s\n",
pmProgname, pmErrStr(bad_pmc.status()));
pmflush();
}
else
sts = 1;
return sts;
}
int
main(int argc, char* argv[])
{
int sts = 0;
int c;
char buf[MAXHOSTNAMELEN];
pmProgname = basename(argv[0]);
while ((c = getopt(argc, argv, "D:?")) != EOF) {
switch (c) {
case 'D':
sts = __pmParseDebug(optarg);
if (sts < 0) {
pmprintf("%s: unrecognized debug flag specification (%s)\n",
pmProgname, optarg);
sts = 1;
}
else {
pmDebug |= sts;
sts = 0;
}
break;
case '?':
default:
sts = 1;
break;
}
}
if (sts) {
pmprintf("Usage: %s\n", pmProgname);
pmflush();
exit(1);
/*NOTREACHED*/
}
(void)gethostname(buf, MAXHOSTNAMELEN);
buf[MAXHOSTNAMELEN-1] = '\0';
mesg("Create two fetch groups");
QmcGroup group1;
pmflush();
QmcGroup group2;
pmflush();
mesg("Add number of instances to both groups");
QmcMetric* numinsts1 = group1.addMetric("dynamic.numinsts");
pmflush();
if (numinsts1->status() < 0)
exit(1);
else
numinsts1->dump(cout);
QmcMetric* numinsts2 = group2.addMetric("dynamic.numinsts");
pmflush();
if (numinsts2->status() < 0)
exit(1);
else
numinsts2->dump(cout);
mesg("Fetch both groups");
group1.fetch();
numinsts1->dump(cout);
group2.fetch();
numinsts2->dump(cout);
mesg("Add dynamic metrics to both groups");
QmcMetric* discrete1 = group1.addMetric("dynamic.discrete", 0.0, true);
pmflush();
if (discrete1->status() < 0)
exit(1);
else
discrete1->dump(cout);
QmcMetric* instant1 = group1.addMetric("dynamic.instant", 0.0, true);
pmflush();
if (instant1->status() < 0)
exit(1);
else
instant1->dump(cout);
QmcMetric* counter1 = group1.addMetric("dynamic.counter", 0.0, true);
pmflush();
if (counter1->status() < 0)
exit(1);
else
counter1->dump(cout);
QmcMetric* discrete2 = group2.addMetric("dynamic.discrete");
pmflush();
if (discrete2->status() < 0)
exit(1);
else
discrete2->dump(cout);
QmcMetric* instant2 = group2.addMetric("dynamic.instant");
pmflush();
if (instant2->status() < 0)
exit(1);
else
instant2->dump(cout);
QmcMetric* counter2 = group2.addMetric("dynamic.counter");
pmflush();
if (counter2->status() < 0)
exit(1);
else
counter2->dump(cout);
mesg("Fetch both groups");
group1.fetch();
dump(numinsts1, discrete1, instant1, counter1);
group2.fetch();
dump(numinsts2, discrete2, instant2, counter2);
mesg("Add an instance");
store(ADD_INST, "1");
mesg("Fetch first group");
group1.fetch();
dump(numinsts1, discrete1, instant1, counter1);
mesg("Update indom for first group");
update(discrete1, instant1, counter1);
mesg("Fetch first group");
group1.fetch();
dump(numinsts1, discrete1, instant1, counter1);
mesg("Fetch first group");
group1.fetch();
dump(numinsts1, discrete1, instant1, counter1);
mesg("Fetch first group");
group1.fetch();
dump(numinsts1, discrete1, instant1, counter1);
mesg("Add another instance");
store(ADD_INST, "5");
mesg("Fetch first group");
group1.fetch();
dump(numinsts1, discrete1, instant1, counter1);
mesg("Update indom for first group");
update(discrete1, instant1, counter1);
mesg("Fetch first group");
group1.fetch();
dump(numinsts1, discrete1, instant1, counter1);
mesg("Fetch first group");
group1.fetch();
dump(numinsts1, discrete1, instant1, counter1);
mesg("Delete first instance");
store(DEL_INST, "1");
mesg("Fetch first group");
group1.fetch();
dump(numinsts1, discrete1, instant1, counter1);
mesg("Update indom for first group");
update(discrete1, instant1, counter1);
mesg("Fetch first group");
group1.fetch();
dump(numinsts1, discrete1, instant1, counter1);
mesg("Fetch second group");
group2.fetch();
dump(numinsts2, discrete2, instant2, counter2);
mesg("Update indom for second group");
update(discrete2, instant2, counter2);
mesg("Fetch second group");
group2.fetch();
dump(numinsts2, discrete2, instant2, counter2);
mesg("Fetch second group");
group2.fetch();
dump(numinsts2, discrete2, instant2, counter2);
mesg("Delete second instance, add new instance");
store(DEL_INST, "5");
store(ADD_INST, "3");
mesg("Fetch first group");
group1.fetch();
dump(numinsts1, discrete1, instant1, counter1);
mesg("Update indom for first group");
update(discrete1, instant1, counter1);
mesg("Fetch first group");
group1.fetch();
dump(numinsts1, discrete1, instant1, counter1);
mesg("Fetch first group");
group1.fetch();
dump(numinsts1, discrete1, instant1, counter1);
mesg("Fetch second group");
group2.fetch();
dump(numinsts2, discrete2, instant2, counter2);
mesg("Update indom for second group");
update(discrete2, instant2, counter2);
mesg("Fetch second group");
group2.fetch();
dump(numinsts2, discrete2, instant2, counter2);
mesg("Fetch second group");
group2.fetch();
dump(numinsts2, discrete2, instant2, counter2);
mesg("Delete third instance");
store(DEL_INST, "3");
mesg("Fetch first group");
group1.fetch();
dump(numinsts1, discrete1, instant1, counter1);
mesg("Update indom for first group");
update(discrete1, instant1, counter1);
mesg("Fetch first group");
group1.fetch();
dump(numinsts1, discrete1, instant1, counter1);
mesg("Fetch second group");
group2.fetch();
dump(numinsts2, discrete2, instant2, counter2);
mesg("Update indom for second group");
update(discrete2, instant2, counter2);
mesg("Fetch second group");
group2.fetch();
dump(numinsts2, discrete2, instant2, counter2);
mesg("Add second instance again");
store(ADD_INST, "5");
mesg("Fetch first group");
group1.fetch();
dump(numinsts1, discrete1, instant1, counter1);
mesg("Update indom for first group");
update(discrete1, instant1, counter1);
mesg("Fetch first group");
group1.fetch();
dump(numinsts1, discrete1, instant1, counter1);
mesg("Fetch second group");
group2.fetch();
dump(numinsts2, discrete2, instant2, counter2);
mesg("Update indom for second group");
update(discrete2, instant2, counter2);
mesg("Fetch second group");
group2.fetch();
dump(numinsts2, discrete2, instant2, counter2);
return 0;
}
int
main(int argc, char *argv[])
{
int c;
int sts;
int ctx;
int i;
int lflag = 0; /* no label by default */
int nfile;
int n;
char *p;
struct dirent **namelist;
__pmContext *ctxp;
char *archpathname; /* from the command line */
char *archdirname; /* after dirname() */
char archname[MAXPATHLEN]; /* full pathname to base of archive name */
while ((c = pmGetOptions(argc, argv, &opts)) != EOF) {
switch (c) {
case 'l': /* display the archive label */
lflag = 1;
break;
case 'v': /* bump verbosity */
vflag++;
break;
}
}
if (!opts.errors && opts.optind >= argc) {
pmprintf("Error: no archive specified\n\n");
opts.errors++;
}
if (opts.errors) {
pmUsageMessage(&opts);
exit(EXIT_FAILURE);
}
sep = __pmPathSeparator();
setlinebuf(stderr);
__pmAddOptArchive(&opts, argv[opts.optind]);
opts.flags &= ~PM_OPTFLAG_DONE;
__pmEndOptions(&opts);
archpathname = argv[opts.optind];
archbasename = strdup(basename(strdup(archpathname)));
/*
* treat foo, foo.index, foo.meta, foo.NNN as all equivalent
* to "foo"
*/
p = strrchr(archbasename, '.');
if (p != NULL) {
if (strcmp(p, ".index") == 0 || strcmp(p, ".meta") == 0)
*p = '\0';
else {
char *q = p;
q++;
if (isdigit(*q)) {
/*
* foo.<digit> ... if archpathname does exist, then
* safe to strip digits, else leave as is for the
* case of, e.g. archive-20150415.041154 which is the
* pmmgr basename for an archive with a first volume
* named archive-20150415.041154.0
*/
if (access(archpathname, F_OK) == 0) {
q++;
while (*q && isdigit(*q))
q++;
if (*q == '\0')
*p = '\0';
}
}
}
}
archdirname = dirname(strdup(archpathname));
if (vflag)
fprintf(stderr, "Scanning for components of archive \"%s\"\n", archpathname);
nfile = scandir(archdirname, &namelist, filter, NULL);
if (nfile < 1) {
fprintf(stderr, "%s: no PCP archive files match \"%s\"\n", pmProgname, archpathname);
exit(EXIT_FAILURE);
}
/*
* Pass 0 for data, metadata and index files ... check physical
* archive record structure, then label record
*/
sts = STS_OK;
for (i = 0; i < nfile; i++) {
char path[MAXPATHLEN];
if (strcmp(archdirname, ".") == 0) {
/* skip ./ prefix */
strncpy(path, namelist[i]->d_name, sizeof(path));
}
else {
snprintf(path, sizeof(path), "%s%c%s", archdirname, sep, namelist[i]->d_name);
}
if (pass0(path) == STS_FATAL)
/* unrepairable or unrepaired error */
sts = STS_FATAL;
}
if (meta_state == STATE_MISSING) {
fprintf(stderr, "%s%c%s.meta: missing metadata file\n", archdirname, sep, archbasename);
sts = STS_FATAL;
}
if (log_state == STATE_MISSING) {
fprintf(stderr, "%s%c%s.0 (or similar): missing log file \n", archdirname, sep, archbasename);
sts = STS_FATAL;
}
if (sts == STS_FATAL) {
if (vflag) fprintf(stderr, "Due to earlier errors, cannot continue ... bye\n");
exit(EXIT_FAILURE);
}
if ((sts = ctx = pmNewContext(PM_CONTEXT_ARCHIVE, archpathname)) < 0) {
fprintf(stderr, "%s: cannot open archive \"%s\": %s\n", pmProgname, archpathname, pmErrStr(sts));
fprintf(stderr, "Checking abandoned.\n");
exit(EXIT_FAILURE);
}
if (pmGetContextOptions(ctx, &opts) < 0) {
pmflush(); /* runtime errors only at this stage */
exit(EXIT_FAILURE);
}
if (lflag)
dumpLabel();
/*
* Note: ctxp->c_lock remains locked throughout ... __pmHandleToPtr()
* is only called once, and a single context is used throughout
* ... so there is no PM_UNLOCK(ctxp->c_lock) anywhere in the
* pmchecklog code.
* This works because ctxp->c_lock is a recursive lock and
* pmchecklog is single-threaded.
*/
if ((n = pmWhichContext()) >= 0) {
if ((ctxp = __pmHandleToPtr(n)) == NULL) {
fprintf(stderr, "%s: botch: __pmHandleToPtr(%d) returns NULL!\n", pmProgname, n);
exit(EXIT_FAILURE);
}
}
else {
fprintf(stderr, "%s: botch: %s!\n", pmProgname, pmErrStr(PM_ERR_NOCONTEXT));
exit(EXIT_FAILURE);
}
if (strcmp(archdirname, ".") == 0)
/* skip ./ prefix */
strncpy(archname, archbasename, sizeof(archname) - 1);
else
snprintf(archname, sizeof(archname), "%s%c%s", archdirname, sep, archbasename);
sts = pass1(ctxp, archname);
if (index_state == STATE_BAD) {
/* prevent subsequent use of bad temporal index */
ctxp->c_archctl->ac_log->l_numti = 0;
}
sts = pass2(ctxp, archname);
sts = pass3(ctxp, archname, &opts);
if (vflag) {
if (result_count > 0)
fprintf(stderr, "Processed %d pmResult records\n", result_count);
if (mark_count > 0)
fprintf(stderr, "Processed %d <mark> records\n", mark_count);
}
return 0;
}
int
main(int argc, char* argv[])
{
int fail = 0, sts = 0;
int c;
char buf[MAXHOSTNAMELEN];
QString source;
pmSetProgname(argv[0]);
while ((c = getopt(argc, argv, "D:?")) != EOF) {
switch (c) {
case 'D':
sts = pmSetDebug(optarg);
if (sts < 0) {
pmprintf("%s: unrecognized debug options specification (%s)\n",
pmGetProgname(), optarg);
fail = 1;
}
break;
case '?':
default:
sts = 1;
break;
}
}
if (fail) {
pmprintf("Usage: %s\n", pmGetProgname());
pmflush();
exit(1);
}
(void)gethostname(buf, MAXHOSTNAMELEN);
buf[MAXHOSTNAMELEN-1] = '\0';
fprintf(stderr, "*** Simple connection ***\n");
source = QString("oview-short");
QmcSource *src1 = QmcSource::getSource(PM_CONTEXT_ARCHIVE, source, false);
if (src1->status() < 0) {
pmprintf("%s: Error: Unable to create context to \"%s\": %s\n",
pmGetProgname(), (const char *)source.toLatin1(),
pmErrStr(src1->status()));
pmflush();
fail = 1;
}
QmcContext context1(src1);
if (context1.handle() < 0) {
pmflush();
fail = 1;
}
context1.dump(cout);
pmID pmid;
uint32_t indomIndex;
fprintf(stderr, "\n*** Cacheing of descriptors and indoms ***\n");
QmcDesc *desc;
QmcIndom *indom = NULL;
sts = context1.lookupInDom("hinv.ncpu", indomIndex);
if (sts < 0) {
pmprintf("%s: Error: hinv.ncpu: %s\n",
pmGetProgname(), pmErrStr(sts));
pmflush();
fail = 1;
}
else {
sts = context1.lookupPMID("hinv.ncpu", pmid);
if (sts < 0) {
pmprintf("%s: Error: hinv.ncpu PMID: %s\n",
pmGetProgname(), pmErrStr(sts));
pmflush();
fail = 1;
}
desc = &context1.desc(pmid);
if (desc->status() < 0) {
pmprintf("%s: Error: hinv.ncpu descriptor: %s\n",
pmGetProgname(), pmErrStr(desc->status()));
pmflush();
fail = 1;
}
else if (indomIndex < UINT_MAX) {
pmprintf("%s: Error: hinv.ncpu indom is not NULL\n",
pmGetProgname());
pmflush();
fail = 1;
}
}
sts = context1.lookupInDom("hinv.cputype", indomIndex);
if (sts < 0) {
pmprintf("%s: Error: hinv.cputype: %s\n",
pmGetProgname(), pmErrStr(sts));
pmflush();
fail = 1;
}
else {
sts = context1.lookupPMID("hinv.cputype", pmid);
if (sts < 0) {
pmprintf("%s: Error: hinv.cputype PMID: %s\n",
pmGetProgname(), pmErrStr(sts));
pmflush();
fail = 1;
}
desc = &context1.desc(pmid);
indom = &context1.indom(indomIndex);
if (desc->status() < 0) {
pmprintf("%s: Error: hinv.cputype descriptor: %s\n",
pmGetProgname(), pmErrStr(desc->status()));
pmflush();
fail = 1;
}
else if (indom->status() < 0) {
pmprintf("%s: Error: hinv.cputype indom: %s\n",
pmGetProgname(), pmErrStr(indom->status()));
pmflush();
fail = 1;
}
}
QmcIndom *indom2;
sts = context1.lookupInDom("hinv.map.cpu", indomIndex);
if (sts < 0) {
pmprintf("%s: Error: hinv.map.cpu: %s\n",
pmGetProgname(), pmErrStr(sts));
pmflush();
fail = 1;
}
else {
sts = context1.lookupPMID("hinv.map.cpu", pmid);
if (sts < 0) {
pmprintf("%s: Error: hinv.map.cpu PMID: %s\n",
pmGetProgname(), pmErrStr(sts));
pmflush();
fail = 1;
}
desc = &context1.desc(pmid);
indom2 = &context1.indom(indomIndex);
if (desc->status() < 0) {
pmprintf("%s: Error: hinv.map.cpu descriptor: %s\n",
pmGetProgname(), pmErrStr(desc->status()));
pmflush();
fail = 1;
}
else if (indom2->status() < 0) {
pmprintf("%s: Error: hinv.map.cpu indom: %s\n",
pmGetProgname(), pmErrStr(indom2->status()));
pmflush();
fail = 1;
}
else if (indom != indom2) {
pmprintf("%s: Error: hinv.cputype and hinv.map.cpu indoms are not the same\n",
pmGetProgname());
pmflush();
fail = 1;
}
}
sts = context1.lookupInDom("hinv.ncpu", indomIndex);
if (sts < 0) {
pmprintf("%s: Error: hinv.ncpu: %s\n",
pmGetProgname(), pmErrStr(sts));
pmflush();
fail = 1;
}
else {
sts = context1.lookupPMID("hinv.ncpu", pmid);
if (sts < 0) {
pmprintf("%s: Error: hinv.ncpu PMID: %s\n",
pmGetProgname(), pmErrStr(sts));
pmflush();
fail = 1;
}
desc = &context1.desc(pmid);
if (desc->status() < 0) {
pmprintf("%s: Error: hinv.ncpu descriptor: %s\n",
pmGetProgname(), pmErrStr(desc->status()));
pmflush();
fail = 1;
}
else if (indomIndex < UINT_MAX) {
pmprintf("%s: Error: hinv.ncpu indom is not NULL\n",
pmGetProgname());
pmflush();
fail = 1;
}
}
context1.dump(cout);
fprintf(stderr, "\n*** Bad Context ***\n");
source = QString("no-such-host");
QmcSource *src2 = QmcSource::getSource(PM_CONTEXT_HOST, source);
if (src2->status() >= 0) {
pmprintf("%s: Error: Able to create context to \"%s\": %s\n",
pmGetProgname(), (const char *)source.toLatin1(),
pmErrStr(src1->status()));
pmflush();
fail = 1;
}
QmcContext context2(src2);
if (context2.handle() >= 0) {
pmprintf("%s: Error: Created a valid context to an invalid host\n",
pmGetProgname());
fail = 1;
}
pmflush();
context2.dump(cout);
fprintf(stderr, "\n*** Exiting ***\n");
pmflush();
return fail;
}
int
main(int argc, char **argv)
{
int c;
char *p;
int ctx;
int sts;
char *configfile = NULL;
int fflag = 0;
int iflag = 0;
int lflag = 0;
pmSetProgname(argv[0]);
while ((c = pmGetOptions(argc, argv, &opts)) != EOF) {
switch (c) {
case 'c': /* my configfile */
if (configfile != NULL) {
fprintf(stderr, "%s: at most one -c option allowed\n", pmGetProgname());
exit(EXIT_FAILURE);
}
configfile = opts.optarg;
break;
case 'f': /* my flag */
fflag++;
break;
case 'i': /* my instances */
iflag++;
/* TODO extract instances from opts.optarg */
break;
case 'l': /* my logfile */
if (lflag) {
fprintf(stderr, "%s: at most one -l option allowed\n", pmGetProgname());
exit(EXIT_FAILURE);
}
pmOpenLog(pmGetProgname(), opts.optarg, stderr, &sts);
if (sts != 1) {
fprintf(stderr, "%s: Could not open logfile \"%s\"\n", pmGetProgname(), opts.optarg);
exit(EXIT_FAILURE);
}
lflag++;
break;
}
}
if (opts.flags & PM_OPTFLAG_EXIT) {
pmflush();
pmUsageMessage(&opts);
exit(0);
}
if (opts.narchives == 1) {
if ((ctx = pmNewContext(PM_CONTEXT_ARCHIVE, opts.archives[0])) < 0) {
fprintf(stderr, "%s: Cannot open archive \"%s\": %s\n",
pmGetProgname(), opts.archives[0], pmErrStr(ctx));
exit(EXIT_FAILURE);
}
if ((sts = pmGetContextOptions(ctx, &opts)) < 0) {
pmflush();
fprintf(stderr, "%s: pmGetContextOptions(%d, ...) failed: %s\n",
pmGetProgname(), pmWhichContext(), pmErrStr(sts));
exit(EXIT_FAILURE);
}
}
else if (opts.narchives > 0) {
fprintf(stderr, "%s: at most one archive allowed\n", pmGetProgname());
exit(EXIT_FAILURE);
}
if (opts.nhosts == 1) {
if ((ctx = pmNewContext(PM_CONTEXT_HOST, opts.hosts[0])) < 0) {
fprintf(stderr, "%s: Cannot connect to pmcd on host \"%s\": %s\n",
pmGetProgname(), opts.hosts[0], pmErrStr(ctx));
exit(EXIT_FAILURE);
}
}
else if (opts.nhosts > 0) {
fprintf(stderr, "%s: at most one host allowed\n", pmGetProgname());
exit(EXIT_FAILURE);
}
if (opts.errors) {
pmUsageMessage(&opts);
exit(EXIT_FAILURE);
}
if (opts.align_optarg != NULL)
printf("Got -A \"%s\"\n", opts.align_optarg);
if (opts.guiflag)
printf("Got -g\n");
if (opts.nsflag)
printf("Loaded PMNS\n");
if (opts.guiport)
printf("Got -p \"%s\"\n", opts.guiport_optarg);
if (opts.align_optarg != NULL || opts.start_optarg != NULL ||
opts.finish_optarg != NULL || opts.origin_optarg != NULL) {
printf("Start time: ");
pmPrintStamp(stdout, &opts.start);
putchar('\n');
printf("Origin time: ");
pmPrintStamp(stdout, &opts.origin);
putchar('\n');
printf("Finish time: ");
pmPrintStamp(stdout, &opts.finish);
putchar('\n');
}
if (sflag)
printf("Got -s \"%d\"\n", opts.samples);
if (opts.interval.tv_sec > 0 || opts.interval.tv_usec > 0)
printf("Got -t %d.%06d (secs)\n",
(int)opts.interval.tv_sec, (int)opts.interval.tv_usec);
p = getenv("PCP_CONTAINER");
if (p != NULL)
printf("Got --container=\"%s\"\n", p);
if (opts.timezone != NULL)
printf("Got -Z \"%s\"\n", opts.timezone);
if (opts.tzflag)
printf("Got -z\n");
if (opts.Lflag)
printf("Got -L\n");
/* non-flag args are argv[optind] ... argv[argc-1] */
while (opts.optind < argc) {
printf("extra argument[%d]: %s\n", opts.optind, argv[opts.optind]);
opts.optind++;
}
while (!sflag || opts.samples-- > 0) {
/* put real stuff here */
break;
}
return 0;
}
/* Return (in result) a list of active pmlogger ports on the local 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
__pmLogFindLocalPorts(int pid, __pmLogPort **result)
{
char dir[MAXPATHLEN];
int lendir;
int i, j, n;
int nf; /* number of port files found */
struct dirent **files = NULL; /* array of port file dirents */
char *p;
int len;
char namebuf[MAXPATHLEN];
int (*scanfn)(const_dirent *dep);
FILE *pfile;
char buf[MAXPATHLEN];
if (PM_MULTIPLE_THREADS(PM_SCOPE_LOGPORT))
return PM_ERR_THREAD;
if (result == NULL)
return -EINVAL;
if ((p = pmGetOptionalConfig("PCP_TMP_DIR")) == NULL)
return PM_ERR_GENERIC;
lendir = snprintf(dir, sizeof(dir), "%s%cpmlogger", p, __pmPathSeparator());
/* Set up the appropriate function to select files from the control port
* directory. Anticipate that this will usually be an exact match for
* the primary logger control port.
*/
scanfn = is_match;
switch (pid) {
case PM_LOG_PRIMARY_PID: /* primary logger control (single) */
strcpy(match, "primary");
break;
case PM_LOG_ALL_PIDS: /* find all ports */
scanfn = is_portfile;
break;
default: /* a specific pid (single) */
if (!__pmProcessExists((pid_t)pid)) {
#ifdef PCP_DEBUG
if (pmDebug & DBG_TRACE_LOG) {
fprintf(stderr, "__pmLogFindLocalPorts() -> 0, "
"pid(%d) doesn't exist\n", pid);
}
#endif
*result = NULL;
return 0;
}
snprintf(match, sizeof(match), "%d", pid);
break;
}
nf = scandir(dir, &files, scanfn, alphasort);
#ifdef PCP_DEBUG
if (nf < 1 && (pmDebug & DBG_TRACE_LOG)) {
fprintf(stderr, "__pmLogFindLocalPorts: scandir() -> %d %s\n",
nf, pmErrStr(oserror()));
}
#endif
if (nf == -1 && oserror() == ENOENT)
nf = 0;
else if (nf == -1) {
char errmsg[PM_MAXERRMSGLEN];
pmprintf("__pmLogFindLocalPorts: scandir: %s\n", osstrerror_r(errmsg, sizeof(errmsg)));
pmflush();
return -oserror();
}
if (resize_logports(nf) < 0) {
for (i=0; i < nf; i++)
free(files[i]);
free(files);
return -oserror();
}
if (nf == 0) {
#ifdef PCP_DEBUG
if (pmDebug & DBG_TRACE_LOG) {
fprintf(stderr, "__pmLogFindLocalPorts() -> 0, "
"num files = 0\n");
}
#endif
*result = NULL;
free(files);
return 0;
}
/* make a buffer for the longest complete pathname found */
len = (int)strlen(files[0]->d_name);
for (i = 1; i < nf; i++)
if ((j = (int)strlen(files[i]->d_name)) > len)
len = j;
/* +1 for trailing path separator, +1 for null termination */
len += lendir + 2;
/* namebuf is the complete pathname, p points to the trailing filename
* within namebuf.
*/
strcpy(namebuf, dir);
p = namebuf + lendir;
*p++ = __pmPathSeparator();
/* open the file, try to read the port number and add the port to the
* logport array if successful.
*/
for (i = 0; i < nf; i++) {
char *fname = files[i]->d_name;
int err = 0;
__pmLogPort *lpp = &logport[nlogports];
strcpy(p, fname);
if ((pfile = fopen(namebuf, "r")) == NULL) {
char errmsg[PM_MAXERRMSGLEN];
pmprintf("__pmLogFindLocalPorts: pmlogger port file %s: %s\n",
namebuf, osstrerror_r(errmsg, sizeof(errmsg)));
free(files[i]);
pmflush();
continue;
}
if (!err && fgets(buf, MAXPATHLEN, pfile) == NULL) {
if (feof(pfile)) {
clearerr(pfile);
pmprintf("__pmLogFindLocalPorts: pmlogger port file %s empty!\n",
namebuf);
}
else {
char errmsg[PM_MAXERRMSGLEN];
pmprintf("__pmLogFindLocalPorts: pmlogger port file %s: %s\n",
namebuf, osstrerror_r(errmsg, sizeof(errmsg)));
}
err = 1;
}
else {
char *endp;
lpp->port = (int)strtol(buf, &endp, 10);
if (*endp != '\n') {
pmprintf("__pmLogFindLocalPorts: pmlogger port file %s: no port number\n",
namebuf);
err = 1;
}
else {
lpp->pid = (int)strtol(fname, &endp, 10);
if (*endp != '\0') {
if (strcmp(fname, "primary") == 0)
lpp->pid = PM_LOG_PRIMARY_PORT;
else {
pmprintf("__pmLogFindLocalPorts: unrecognised pmlogger port file %s\n",
namebuf);
err = 1;
}
}
}
}
if (err) {
pmflush();
fclose(pfile);
}
else {
if (fgets(buf, MAXPATHLEN, pfile) == NULL) {
pmprintf("__pmLogFindLocalPorts: pmlogger port file %s: no PMCD host name\n",
namebuf);
pmflush();
}
else {
char *q = strchr(buf, '\n');
if (q != NULL)
*q = '\0';
lpp->pmcd_host = strdup(buf);
if (fgets(buf, MAXPATHLEN, pfile) == NULL) {
pmprintf("__pmLogFindLocalPorts: pmlogger port file %s: no archive base pathname\n",
namebuf);
pmflush();
}
else {
char *q = strchr(buf, '\n');
if (q != NULL)
*q = '\0';
lpp->archive = strdup(buf);
}
}
fclose(pfile);
if ((lpp->name = strdup(fname)) != NULL)
nlogports++;
else {
if (lpp->pmcd_host != NULL) {
free(lpp->pmcd_host);
lpp->pmcd_host = NULL;
}
if (lpp->archive != NULL) {
free(lpp->archive);
lpp->archive = NULL;
}
break;
}
}
free(files[i]);
}
if (i == nf) { /* all went well */
n = nlogports;
*result = logport;
}
else { /* strdup error on fname, clean up */
*result = NULL;
for (j = i; j < nf; j++)
free(files[j]);
n = -oserror();
}
free(files);
return n;
}
int
main(int argc, char *argv[])
{
int c;
int sts;
char *rawfile = NULL;
int i;
int ctxid;
int first = 1;
int dflag = 0;
int iflag = 0;
int Lflag = 0;
int lflag = 0;
int Mflag = 0;
int mflag = 0;
int tflag = 0;
int vflag = 0;
int mode = PM_MODE_FORW;
__pmContext *ctxp;
pmResult *raw_result;
pmResult *skel_result = NULL;
pmResult *result;
struct timeval done;
while ((c = pmGetOptions(argc, argv, &opts)) != EOF) {
switch (c) {
case 'a': /* dump everything */
dflag = iflag = lflag = mflag = sflag = tflag = 1;
break;
case 'd': /* dump pmDesc structures */
dflag = 1;
break;
case 'i': /* dump instance domains */
iflag = 1;
break;
case 'L': /* dump label, verbose */
Lflag = 1;
lflag = 1;
break;
case 'l': /* dump label */
lflag = 1;
break;
case 'm': /* dump metrics in log */
mflag = 1;
break;
case 'M': /* report <mark> records */
Mflag = 1;
break;
case 'r': /* read log in reverse chornological order */
mode = PM_MODE_BACK;
break;
case 's': /* report data size in log */
sflag = 1;
break;
case 't': /* dump temporal index */
tflag = 1;
break;
case 'v': /* verbose, dump in raw format */
vflag = 1;
rawfile = opts.optarg;
break;
case 'x': /* report Ddd Mmm DD <timestamp> YYYY */
/* -xx reports numeric timeval also */
xflag++;
break;
}
}
if (opts.errors ||
(vflag && opts.optind != argc) ||
(!vflag && opts.optind > argc - 1 && !opts.narchives)) {
pmUsageMessage(&opts);
exit(1);
}
if (vflag) {
FILE *f;
if ((f = fopen(rawfile, "r")) == NULL) {
fprintf(stderr, "%s: Cannot open \"%s\": %s\n", pmProgname, rawfile, osstrerror());
exit(1);
}
printf("Raw dump of physical archive file \"%s\" ...\n", rawfile);
rawdump(f);
exit(0);
}
if (dflag + iflag + lflag + mflag + tflag == 0)
mflag = 1; /* default */
/* delay option end processing until now that we have the archive name */
if (opts.narchives == 0)
__pmAddOptArchive(&opts, argv[opts.optind++]);
opts.flags &= ~PM_OPTFLAG_DONE;
__pmEndOptions(&opts);
if ((sts = ctxid = pmNewContext(PM_CONTEXT_ARCHIVE, opts.archives[0])) < 0) {
fprintf(stderr, "%s: Cannot open archive \"%s\": %s\n",
pmProgname, opts.archives[0], pmErrStr(sts));
exit(1);
}
/* complete TZ and time window option (origin) setup */
if (pmGetContextOptions(ctxid, &opts)) {
pmflush();
exit(1);
}
numpmid = argc - opts.optind;
if (numpmid) {
numpmid = 0;
pmid = NULL;
for (i = 0; opts.optind < argc; i++, opts.optind++) {
numpmid++;
pmid = (pmID *)realloc(pmid, numpmid * sizeof(pmID));
if ((sts = pmLookupName(1, &argv[opts.optind], &pmid[numpmid-1])) < 0) {
if (sts == PM_ERR_NONLEAF) {
numpmid--;
if ((sts = pmTraversePMNS(argv[opts.optind], dometric)) < 0)
fprintf(stderr, "%s: pmTraversePMNS(%s): %s\n",
pmProgname, argv[opts.optind], pmErrStr(sts));
}
else
fprintf(stderr, "%s: pmLookupName(%s): %s\n",
pmProgname, argv[opts.optind], pmErrStr(sts));
if (sts < 0)
numpmid--;
}
}
if (numpmid == 0) {
fprintf(stderr, "No metric names can be translated, dump abandoned\n");
exit(1);
}
}
if ((sts = pmGetArchiveLabel(&label)) < 0) {
fprintf(stderr, "%s: Cannot get archive label record: %s\n",
pmProgname, pmErrStr(sts));
exit(1);
}
if (numpmid > 0) {
/*
* setup dummy pmResult
*/
skel_result = (pmResult *)malloc(sizeof(pmResult)+(numpmid-1)*sizeof(pmValueSet *));
if (skel_result == NULL) {
fprintf(stderr, "%s: malloc(skel_result): %s\n", pmProgname, osstrerror());
exit(1);
}
}
/*
* Note: ctxp->c_lock remains locked throughout ... __pmHandleToPtr()
* is only called once, and a single context is used throughout
* ... so there is no PM_UNLOCK(ctxp->c_lock) anywhere in the
* pmdumplog code.
* This works because ctxp->c_lock is a recursive lock and
* pmdumplog is single-threaded.
*/
if ((ctxp = __pmHandleToPtr(ctxid)) == NULL) {
fprintf(stderr, "%s: botch: __pmHandleToPtr(%d) returns NULL!\n",
pmProgname, ctxid);
exit(1);
}
pmSetMode(mode, &opts.start, 0);
if (lflag)
dumpLabel(Lflag);
if (dflag)
dumpDesc(ctxp);
if (iflag)
dumpInDom(ctxp);
if (tflag)
dumpTI(ctxp);
if (mflag) {
if (mode == PM_MODE_FORW) {
if (opts.start_optarg != NULL || opts.finish_optarg != NULL) {
/* -S or -T */
sts = pmSetMode(mode, &opts.start, 0);
done = opts.finish;
}
else {
/* read the whole archive */
done.tv_sec = 0;
done.tv_usec = 0;
sts = pmSetMode(mode, &done, 0);
done.tv_sec = INT_MAX;
}
}
else {
if (opts.start_optarg != NULL || opts.finish_optarg != NULL) {
/* -S or -T */
done.tv_sec = INT_MAX;
done.tv_usec = 0;
sts = pmSetMode(mode, &done, 0);
done = opts.start;
}
else {
/* read the whole archive backwards */
done.tv_sec = INT_MAX;
done.tv_usec = 0;
sts = pmSetMode(mode, &done, 0);
done.tv_sec = 0;
}
}
if (sts < 0) {
fprintf(stderr, "%s: pmSetMode: %s\n", pmProgname, pmErrStr(sts));
exit(1);
}
sts = 0;
for ( ; ; ) {
sts = __pmLogFetch(ctxp, 0, NULL, &raw_result);
if (sts < 0)
break;
if (numpmid == 0 || (raw_result->numpmid == 0 && Mflag)) {
/*
* want 'em all or <mark> record ...
*/
result = raw_result;
}
else if (numpmid > 0) {
/*
* cherry pick from raw_result if pmid matches one
* of interest
*/
int picked = 0;
int j;
skel_result->timestamp = raw_result->timestamp;
for (j = 0; j < numpmid; j++)
skel_result->vset[j] = NULL;
for (i = 0; i < raw_result->numpmid; i++) {
for (j = 0; j < numpmid; j++) {
if (pmid[j] == raw_result->vset[i]->pmid) {
skel_result->vset[j] = raw_result->vset[i];
picked++;
break;
}
}
}
if (picked == 0) {
/* no metrics of interest, skip this record */
pmFreeResult(raw_result);
continue;
}
skel_result->numpmid = picked;
if (picked != numpmid) {
/* did not find 'em all ... shuffle time */
int j;
i = 0;
for (j = 0; j < numpmid; j++) {
if (skel_result->vset[j] != NULL)
skel_result->vset[i++] = skel_result->vset[j];
}
}
result = skel_result;
}
else {
/* not interesting */
pmFreeResult(raw_result);
continue;
}
if (first && mode == PM_MODE_BACK) {
first = 0;
printf("\nLog finished at %24.24s - dump in reverse order\n",
pmCtime(&result->timestamp.tv_sec, timebuf));
}
if ((mode == PM_MODE_FORW && tvcmp(result->timestamp, done) > 0) ||
(mode == PM_MODE_BACK && tvcmp(result->timestamp, done) < 0)) {
sts = PM_ERR_EOL;
break;
}
putchar('\n');
dump_result(result);
pmFreeResult(raw_result);
}
if (sts != PM_ERR_EOL) {
fprintf(stderr, "%s: pmFetch: %s\n", pmProgname, pmErrStr(sts));
exit(1);
}
}
exit(0);
}
int
main(int argc, char **argv)
{
int a, c;
int sts;
int exitsts = 0;
char *source;
char *endnum;
while ((c = pmGetOptions(argc, argv, &opts)) != EOF) {
switch (c) {
case 'b': /* batchsize */
batchsize = (int)strtol(opts.optarg, &endnum, 10);
if (*endnum != '\0') {
pmprintf("%s: -b requires numeric argument\n", pmProgname);
opts.errors++;
}
break;
case 'c': /* derived metrics config file */
sts = pmLoadDerivedConfig(opts.optarg);
if (sts < 0) {
fprintf(stderr, "%s: derived configuration(s) error: %s\n", pmProgname, pmErrStr(sts));
/* errors are not necessarily fatal ... */
}
break;
case 'd':
p_desc = 1;
need_context = 1;
need_pmid = 1;
break;
case 'F':
p_force = p_value = 1;
need_context = 1;
need_pmid = 1;
break;
case 'f':
p_value = 1;
need_context = 1;
need_pmid = 1;
break;
case 'M':
p_fullmid = 1;
p_mid = 1;
need_pmid = 1;
break;
case 'm':
p_mid = 1;
need_pmid = 1;
break;
case 't':
p_oneline = 1;
need_context = 1;
need_pmid = 1;
break;
case 'T':
p_help = 1;
need_context = 1;
need_pmid = 1;
break;
case 'v':
verify = 1;
need_context = 1;
need_pmid = 1;
break;
case 'x':
events = p_value = 1;
need_context = 1;
need_pmid = 1;
break;
}
}
if (opts.errors) {
pmUsageMessage(&opts);
exit(1);
}
if (opts.context)
need_context = 1;
if (opts.context == PM_CONTEXT_ARCHIVE)
/*
* for archives, one metric per batch and start at beginning of
* archive for each batch so metric will be found if it is in
* the archive
*/
batchsize = 1;
if (verify)
p_desc = p_mid = p_fullmid = p_help = p_oneline = p_value = p_force = 0;
if ((namelist = (char **)malloc(batchsize * sizeof(char *))) == NULL) {
fprintf(stderr, "%s: namelist malloc: %s\n", pmProgname, osstrerror());
exit(1);
}
if ((pmidlist = (pmID *)malloc(batchsize * sizeof(pmID))) == NULL) {
fprintf(stderr, "%s: pmidlist malloc: %s\n", pmProgname, osstrerror());
exit(1);
}
if (!opts.nsflag)
need_context = 1; /* for distributed PMNS as no PMNS file given */
if (need_context) {
int ctxid;
if (opts.context == PM_CONTEXT_ARCHIVE)
source = opts.archives[0];
else 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_HOST)
fprintf(stderr, "%s: Cannot connect to PMCD on host \"%s\": %s\n",
pmProgname, source, pmErrStr(sts));
else if (opts.context == PM_CONTEXT_LOCAL)
fprintf(stderr, "%s: Cannot make standalone connection on localhost: %s\n",
pmProgname, pmErrStr(sts));
else
fprintf(stderr, "%s: Cannot open archive \"%s\": %s\n",
pmProgname, source, pmErrStr(sts));
exit(1);
}
ctxid = sts;
if (opts.context == PM_CONTEXT_ARCHIVE) {
pmTrimNameSpace();
/* complete TZ and time window option (origin) setup */
if (pmGetContextOptions(ctxid, &opts)) {
pmflush();
exit(1);
}
}
}
if (opts.optind >= argc) {
sts = pmTraversePMNS("", dometric);
if (sts < 0) {
fprintf(stderr, "Error: %s\n", pmErrStr(sts));
exitsts = 1;
}
}
else {
for (a = opts.optind; a < argc; a++) {
sts = pmTraversePMNS(argv[a], dometric);
if (sts < 0) {
fprintf(stderr, "Error: %s: %s\n", argv[a], pmErrStr(sts));
exitsts = 1;
}
}
}
report();
exit(exitsts);
}
