QmcGroup::QmcGroup(bool restrictArchives)
{
my.restrictArchives = restrictArchives;
my.mode = PM_CONTEXT_HOST;
my.use = -1;
my.localSource = 0;
my.tzFlag = unknownTZ;
my.tzDefault = -1;
my.tzUser = -1;
my.tzGroupIndex = 0;
my.timeEndReal = 0.0;
// Get timezone from environment
if (tzLocalInit == false) {
localHost = QmcSource::getLocalHost();
char *tz = __pmTimezone();
if (tz == NULL)
pmprintf("%s: Warning: Unable to get timezone from environment\n",
pmProgname);
else {
tzLocal = pmNewZone(tz);
if (tzLocal < 0)
pmprintf("%s: Warning: Timezone for localhost: %s\n",
pmProgname, pmErrStr(tzLocal));
else {
tzLocalString = tz;
my.tzDefault = tzLocal;
my.tzFlag = localTZ;
}
}
tzLocalInit = true;
}
}
/* initialize timezone */
void
zoneInit(void)
{
int sts;
int handle = -1;
Archive *a;
if (timeZone) { /* TZ from timezone string */
if ((sts = pmNewZone(timeZone)) < 0)
fprintf(stderr, "%s: cannot set timezone to %s\n"
"pmNewZone failed: %s\n", pmProgname, timeZone,
pmErrStr(sts));
}
else if (! archives && hostZone) { /* TZ from live host */
if ((handle = pmNewContext(PM_CONTEXT_HOST, dfltHostConn)) < 0)
fprintf(stderr, "%s: cannot set timezone from %s\n"
"pmNewContext failed: %s\n", pmProgname,
findsource(dfltHostConn), pmErrStr(handle));
else if ((sts = pmNewContextZone()) < 0)
fprintf(stderr, "%s: cannot set timezone from %s\n"
"pmNewContextZone failed: %s\n", pmProgname,
findsource(dfltHostConn), pmErrStr(sts));
else
fprintf(stdout, "%s: timezone set to local timezone of host %s\n",
pmProgname, dfltHostConn);
if (handle >= 0)
pmDestroyContext(handle);
}
else if (hostZone) { /* TZ from an archive */
a = archives;
while (a) {
if (strcmp(dfltHostName, a->hname) == 0)
break;
a = a->next;
}
if (! a)
fprintf(stderr, "%s: no archive supplied for host %s\n",
pmProgname, dfltHostName);
else if ((handle = pmNewContext(PM_CONTEXT_ARCHIVE, a->fname)) < 0)
fprintf(stderr, "%s: cannot set timezone from %s\npmNewContext failed: %s\n",
pmProgname, findsource(dfltHostName), pmErrStr(handle));
else if ((sts = pmNewContextZone()) < 0)
fprintf(stderr, "%s: cannot set timezone from %s\n"
"pmNewContextZone failed: %s\n",
pmProgname, findsource(dfltHostName), pmErrStr(sts));
else
fprintf(stdout, "%s: timezone set to local timezone of host %s\n",
pmProgname, dfltHostName);
if (handle >= 0)
pmDestroyContext(handle);
}
}
int
QmcGroup::useTZ(const QString &tz)
{
int sts = pmNewZone(tz.toAscii());
if (sts >= 0) {
my.tzUser = sts;
my.tzUserString = tz;
my.tzFlag = userTZ;
my.tzDefault = sts;
if (pmDebug & DBG_TRACE_PMC) {
QTextStream cerr(stderr);
cerr << "QmcGroup::useTZ: Switching timezones to \"" << tz
<< "\" (" << my.tzUserString << ')' << endl;
}
}
return sts;
}
int
main(int argc, char **argv)
{
int sts;
char *msg;
pmResult *irp; /* input pmResult */
pmResult *orp; /* output pmResult */
__pmPDU *pb; /* pdu buffer */
struct timeval unused;
unsigned long peek_offset;
/* process cmd line args */
if (parseargs(argc, argv) < 0) {
pmUsageMessage(&opts);
exit(1);
}
/* input archive name is argv[opts.optind] */
/* output archive name is argv[argc-1]) */
/* output archive */
oname = argv[argc-1];
/* input archive */
iname = argv[opts.optind];
/*
* This is the interp mode context
*/
if ((ictx_a = pmNewContext(PM_CONTEXT_ARCHIVE, iname)) < 0) {
fprintf(stderr, "%s: Error: cannot open archive \"%s\" (ctx_a): %s\n",
pmProgname, iname, pmErrStr(ictx_a));
exit(1);
}
if ((sts = pmGetArchiveLabel(&ilabel)) < 0) {
fprintf(stderr, "%s: Error: cannot get archive label record (%s): %s\n", pmProgname, iname, pmErrStr(sts));
exit(1);
}
/* start time */
logstart_tval.tv_sec = ilabel.ll_start.tv_sec;
logstart_tval.tv_usec = ilabel.ll_start.tv_usec;
/* end time */
if ((sts = pmGetArchiveEnd(&logend_tval)) < 0) {
fprintf(stderr, "%s: Error: cannot get end of archive (%s): %s\n",
pmProgname, iname, pmErrStr(sts));
exit(1);
}
if (zarg) {
/* use TZ from metrics source (input-archive) */
if ((sts = pmNewZone(ilabel.ll_tz)) < 0) {
fprintf(stderr, "%s: Cannot set context timezone: %s\n",
pmProgname, pmErrStr(sts));
exit(1);
}
printf("Note: timezone set to local timezone of host \"%s\" from archive\n\n", ilabel.ll_hostname);
}
else if (tz != NULL) {
/* use TZ as specified by user */
if ((sts = pmNewZone(tz)) < 0) {
fprintf(stderr, "%s: Cannot set timezone to \"%s\": %s\n",
pmProgname, tz, pmErrStr(sts));
exit(1);
}
printf("Note: timezone set to \"TZ=%s\"\n\n", tz);
}
else {
char *tz;
tz = __pmTimezone();
/* use TZ from local host */
if ((sts = pmNewZone(tz)) < 0) {
fprintf(stderr, "%s: Cannot set local host's timezone: %s\n",
pmProgname, pmErrStr(sts));
exit(1);
}
}
/* set winstart and winend timevals */
sts = pmParseTimeWindow(Sarg, Targ, Aarg, Oarg,
&logstart_tval, &logend_tval,
&winstart_tval, &winend_tval, &unused, &msg);
if (sts < 0) {
fprintf(stderr, "%s: Invalid time window specified: %s\n",
pmProgname, msg);
exit(1);
}
#if PCP_DEBUG
if (pmDebug & DBG_TRACE_APPL0) {
char buf[26];
pmCtime((const time_t *)&winstart_tval.tv_sec, buf);
fprintf(stderr, "Start time: %s", buf);
pmCtime((const time_t *)&winend_tval.tv_sec, buf);
fprintf(stderr, "End time: %s", buf);
}
#endif
if ((sts = pmSetMode(PM_MODE_INTERP | PM_XTB_SET(PM_TIME_SEC),
&winstart_tval, (int)targ)) < 0) {
fprintf(stderr, "%s: pmSetMode(PM_MODE_INTERP ...) failed: %s\n",
pmProgname, pmErrStr(sts));
exit(1);
}
/* create output log - must be done before writing label */
if ((sts = __pmLogCreate("", oname, PM_LOG_VERS02, &logctl)) < 0) {
fprintf(stderr, "%s: Error: __pmLogCreate: %s\n",
pmProgname, pmErrStr(sts));
exit(1);
}
/* This must be done after log is created:
* - checks that archive version, host, and timezone are ok
* - set archive version, host, and timezone of output archive
* - set start time
* - write labels
*/
newlabel();
current.tv_sec = logctl.l_label.ill_start.tv_sec = winstart_tval.tv_sec;
current.tv_usec = logctl.l_label.ill_start.tv_usec = winstart_tval.tv_usec;
/* write label record */
writelabel();
/*
* Supress any automatic label creation in libpcp at the first
* pmResult write.
*/
logctl.l_state = PM_LOG_STATE_INIT;
/*
* Traverse the PMNS to get all the metrics and their metadata
*/
if ((sts = pmTraversePMNS ("", dometric)) < 0) {
fprintf(stderr, "%s: Error traversing namespace ... %s\n",
pmProgname, pmErrStr(sts));
goto cleanup;
}
/*
* All the initial metadata has been generated, add timestamp
*/
fflush(logctl.l_mdfp);
__pmLogPutIndex(&logctl, ¤t);
written = 0;
/*
* main loop
*/
while (sarg == -1 || written < sarg) {
/*
* do stuff
*/
if ((sts = pmUseContext(ictx_a)) < 0) {
fprintf(stderr, "%s: Error: cannot use context (%s): %s\n",
pmProgname, iname, pmErrStr(sts));
goto cleanup;
}
if ((sts = pmFetch(numpmid, pmidlist, &irp)) < 0) {
if (sts == PM_ERR_EOL)
break;
fprintf(stderr,
"%s: Error: pmFetch failed: %s\n", pmProgname, pmErrStr(sts));
exit(1);
}
if (irp->timestamp.tv_sec > winend_tval.tv_sec ||
(irp->timestamp.tv_sec == winend_tval.tv_sec &&
irp->timestamp.tv_usec > winend_tval.tv_usec)) {
/* past end time as per -T */
break;
}
#if PCP_DEBUG
if (pmDebug & DBG_TRACE_APPL2) {
fprintf(stderr, "input record ...\n");
__pmDumpResult(stderr, irp);
}
#endif
/*
* traverse the interval, looking at every archive record ...
* we are particularly interested in:
* - metric-values that are interpolated but not present in
* this interval
* - counter wraps
* - mark records
*/
doscan(&irp->timestamp);
if ((sts = pmUseContext(ictx_a)) < 0) {
fprintf(stderr, "%s: Error: cannot use context (%s): %s\n",
pmProgname, iname, pmErrStr(sts));
goto cleanup;
}
orp = rewrite(irp);
#if PCP_DEBUG
if (pmDebug & DBG_TRACE_APPL2) {
if (orp == NULL)
fprintf(stderr, "output record ... none!\n");
else {
fprintf(stderr, "output record ...\n");
__pmDumpResult(stderr, orp);
}
}
#endif
if (orp == NULL)
goto next;
/*
* convert log record to a PDU, and enforce V2 encoding semantics,
* then write it out
*/
sts = __pmEncodeResult(PDU_OVERRIDE2, orp, &pb);
if (sts < 0) {
fprintf(stderr, "%s: Error: __pmEncodeResult: %s\n",
pmProgname, pmErrStr(sts));
goto cleanup;
}
/* switch volumes if required */
if (varg > 0) {
if (written > 0 && (written % varg) == 0) {
__pmTimeval next_stamp;
next_stamp.tv_sec = irp->timestamp.tv_sec;
next_stamp.tv_usec = irp->timestamp.tv_usec;
newvolume(oname, &next_stamp);
}
}
/*
* Even without a -v option, we may need to switch volumes
* if the data file exceeds 2^31-1 bytes
*/
peek_offset = ftell(logctl.l_mfp);
peek_offset += ((__pmPDUHdr *)pb)->len - sizeof(__pmPDUHdr) + 2*sizeof(int);
if (peek_offset > 0x7fffffff) {
__pmTimeval next_stamp;
next_stamp.tv_sec = irp->timestamp.tv_sec;
next_stamp.tv_usec = irp->timestamp.tv_usec;
newvolume(oname, &next_stamp);
}
current.tv_sec = orp->timestamp.tv_sec;
current.tv_usec = orp->timestamp.tv_usec;
doindom(orp);
/* write out log record */
sts = __pmLogPutResult2(&logctl, pb);
__pmUnpinPDUBuf(pb);
if (sts < 0) {
fprintf(stderr, "%s: Error: __pmLogPutResult2: log data: %s\n",
pmProgname, pmErrStr(sts));
goto cleanup;
}
written++;
rewrite_free();
next:
pmFreeResult(irp);
}
/* write the last time stamp */
fflush(logctl.l_mfp);
fflush(logctl.l_mdfp);
__pmLogPutIndex(&logctl, ¤t);
exit(exit_status);
cleanup:
{
char fname[MAXNAMELEN];
fprintf(stderr, "Archive \"%s\" not created.\n", oname);
snprintf(fname, sizeof(fname), "%s.0", oname);
unlink(fname);
snprintf(fname, sizeof(fname), "%s.meta", oname);
unlink(fname);
snprintf(fname, sizeof(fname), "%s.index", oname);
unlink(fname);
exit(1);
}
}
int
main(int argc, char **argv)
{
int c;
int sts;
int sep = __pmPathSeparator();
int use_localtime = 0;
int isdaemon = 0;
char *pmnsfile = PM_NS_DEFAULT;
char *username;
char *logfile = "pmlogger.log";
/* default log (not archive) file name */
char *endnum;
int i;
task_t *tp;
optcost_t ocp;
__pmFdSet readyfds;
char *p;
char *runtime = NULL;
int ctx; /* handle corresponding to ctxp below */
__pmContext *ctxp; /* pmlogger has just this one context */
int niter;
pid_t target_pid = 0;
__pmGetUsername(&username);
/*
* Warning:
* If any of the pmlogger options change, make sure the
* corresponding changes are made to pmnewlog when pmlogger
* options are passed through from the control file
*/
while ((c = pmgetopt_r(argc, argv, &opts)) != EOF) {
switch (c) {
case 'c': /* config file */
if (access(opts.optarg, F_OK) == 0)
configfile = opts.optarg;
else {
/* does not exist as given, try the standard place */
char *sysconf = pmGetConfig("PCP_VAR_DIR");
int sz = strlen(sysconf)+strlen("/config/pmlogger/")+strlen(opts.optarg)+1;
if ((configfile = (char *)malloc(sz)) == NULL)
__pmNoMem("config file name", sz, PM_FATAL_ERR);
snprintf(configfile, sz,
"%s%c" "config%c" "pmlogger%c" "%s",
sysconf, sep, sep, sep, opts.optarg);
if (access(configfile, F_OK) != 0) {
/* still no good, error handling happens below */
free(configfile);
configfile = opts.optarg;
}
}
break;
case 'D': /* debug flag */
sts = __pmParseDebug(opts.optarg);
if (sts < 0) {
pmprintf("%s: unrecognized debug flag specification (%s)\n",
pmProgname, opts.optarg);
opts.errors++;
}
else
pmDebug |= sts;
break;
case 'h': /* hostname for PMCD to contact */
pmcd_host_conn = opts.optarg;
break;
case 'l': /* log file name */
logfile = opts.optarg;
break;
case 'L': /* linger if not primary logger */
linger = 1;
break;
case 'm': /* note for port map file */
note = opts.optarg;
isdaemon = ((strcmp(note, "pmlogger_check") == 0) ||
(strcmp(note, "pmlogger_daily") == 0));
break;
case 'n': /* alternative name space file */
pmnsfile = opts.optarg;
break;
case 'p':
target_pid = (int)strtol(opts.optarg, &endnum, 10);
if (*endnum != '\0') {
pmprintf("%s: invalid process identifier (%s)\n",
pmProgname, opts.optarg);
opts.errors++;
} else if (!__pmProcessExists(target_pid)) {
pmprintf("%s: PID error - no such process (%d)\n",
pmProgname, target_pid);
opts.errors++;
}
break;
case 'P': /* this is the primary pmlogger */
primary = 1;
isdaemon = 1;
break;
case 'r': /* report sizes of pmResult records */
rflag = 1;
break;
case 's': /* exit size */
sts = ParseSize(opts.optarg, &exit_samples, &exit_bytes, &exit_time);
if (sts < 0) {
pmprintf("%s: illegal size argument '%s' for exit size\n",
pmProgname, opts.optarg);
opts.errors++;
}
else if (exit_time.tv_sec > 0) {
__pmAFregister(&exit_time, NULL, run_done_callback);
}
break;
case 'T': /* end time */
runtime = opts.optarg;
break;
case 't': /* change default logging interval */
if (pmParseInterval(opts.optarg, &delta, &p) < 0) {
pmprintf("%s: illegal -t argument\n%s", pmProgname, p);
free(p);
opts.errors++;
}
break;
case 'U': /* run as named user */
username = opts.optarg;
isdaemon = 1;
break;
case 'u': /* flush output buffers after each fetch */
/*
* all archive write I/O is unbuffered now, so maintain -u
* for backwards compatibility only
*/
break;
case 'v': /* volume switch after given size */
sts = ParseSize(opts.optarg, &vol_switch_samples, &vol_switch_bytes,
&vol_switch_time);
if (sts < 0) {
pmprintf("%s: illegal size argument '%s' for volume size\n",
pmProgname, opts.optarg);
opts.errors++;
}
else if (vol_switch_time.tv_sec > 0) {
vol_switch_afid = __pmAFregister(&vol_switch_time, NULL,
vol_switch_callback);
}
break;
case 'V':
archive_version = (int)strtol(opts.optarg, &endnum, 10);
if (*endnum != '\0' || archive_version != PM_LOG_VERS02) {
pmprintf("%s: -V requires a version number of %d\n",
pmProgname, PM_LOG_VERS02);
opts.errors++;
}
break;
case 'x': /* recording session control fd */
rsc_fd = (int)strtol(opts.optarg, &endnum, 10);
if (*endnum != '\0' || rsc_fd < 0) {
pmprintf("%s: -x requires a non-negative numeric argument\n", pmProgname);
opts.errors++;
}
else {
time(&rsc_start);
}
break;
case 'y':
use_localtime = 1;
break;
case '?':
default:
opts.errors++;
break;
}
}
if (primary && pmcd_host != NULL) {
pmprintf(
"%s: -P and -h are mutually exclusive; use -P only when running\n"
"%s on the same (local) host as the PMCD to which it connects.\n",
pmProgname, pmProgname);
opts.errors++;
}
if (!opts.errors && opts.optind != argc - 1) {
pmprintf("%s: insufficient arguments\n", pmProgname);
opts.errors++;
}
if (opts.errors) {
pmUsageMessage(&opts);
exit(1);
}
if (rsc_fd != -1 && note == NULL) {
/* add default note to indicate running with -x */
static char xnote[10];
snprintf(xnote, sizeof(xnote), "-x %d", rsc_fd);
note = xnote;
}
/* if we are running as a daemon, change user early */
if (isdaemon)
__pmSetProcessIdentity(username);
__pmOpenLog("pmlogger", logfile, stderr, &sts);
if (sts != 1) {
fprintf(stderr, "%s: Warning: log file (%s) creation failed\n", pmProgname, logfile);
/* continue on ... writing to stderr */
}
/* base name for archive is here ... */
archBase = argv[opts.optind];
if (pmcd_host_conn == NULL)
pmcd_host_conn = "local:";
/* initialise access control */
if (__pmAccAddOp(PM_OP_LOG_ADV) < 0 ||
__pmAccAddOp(PM_OP_LOG_MAND) < 0 ||
__pmAccAddOp(PM_OP_LOG_ENQ) < 0) {
fprintf(stderr, "%s: access control initialisation failed\n", pmProgname);
exit(1);
}
if (pmnsfile != PM_NS_DEFAULT) {
if ((sts = pmLoadASCIINameSpace(pmnsfile, 1)) < 0) {
fprintf(stderr, "%s: Cannot load namespace from \"%s\": %s\n", pmProgname, pmnsfile, pmErrStr(sts));
exit(1);
}
}
if ((ctx = pmNewContext(PM_CONTEXT_HOST, pmcd_host_conn)) < 0) {
fprintf(stderr, "%s: Cannot connect to PMCD on host \"%s\": %s\n", pmProgname, pmcd_host_conn, pmErrStr(ctx));
exit(1);
}
pmcd_host = (char *)pmGetContextHostName(ctx);
if (strlen(pmcd_host) == 0) {
fprintf(stderr, "%s: pmGetContextHostName(%d) failed\n",
pmProgname, ctx);
exit(1);
}
if (rsc_fd == -1) {
/* no -x, so register client id with pmcd */
__pmSetClientIdArgv(argc, argv);
}
/*
* discover fd for comms channel to PMCD ...
*/
if ((ctxp = __pmHandleToPtr(ctx)) == NULL) {
fprintf(stderr, "%s: botch: __pmHandleToPtr(%d) returns NULL!\n", pmProgname, ctx);
exit(1);
}
pmcdfd = ctxp->c_pmcd->pc_fd;
PM_UNLOCK(ctxp->c_lock);
if (configfile != NULL) {
if ((yyin = fopen(configfile, "r")) == NULL) {
fprintf(stderr, "%s: Cannot open config file \"%s\": %s\n",
pmProgname, configfile, osstrerror());
exit(1);
}
}
else {
/* **ANY** Lex would read from stdin automagically */
configfile = "<stdin>";
}
__pmOptFetchGetParams(&ocp);
ocp.c_scope = 1;
__pmOptFetchPutParams(&ocp);
/* prevent early timer events ... */
__pmAFblock();
if (yyparse() != 0)
exit(1);
if (configfile != NULL)
fclose(yyin);
yyend();
#ifdef PCP_DEBUG
fprintf(stderr, "Config parsed\n");
#endif
fprintf(stderr, "Starting %slogger for host \"%s\" via \"%s\"\n",
primary ? "primary " : "", pmcd_host, pmcd_host_conn);
#ifdef PCP_DEBUG
if (pmDebug & DBG_TRACE_LOG) {
fprintf(stderr, "optFetch Cost Parameters: pmid=%d indom=%d fetch=%d scope=%d\n",
ocp.c_pmid, ocp.c_indom, ocp.c_fetch, ocp.c_scope);
fprintf(stderr, "\nAfter loading config ...\n");
for (tp = tasklist; tp != NULL; tp = tp->t_next) {
if (tp->t_numvalid == 0)
continue;
fprintf(stderr, " state: %sin log, %savail, %s, %s",
PMLC_GET_INLOG(tp->t_state) ? "" : "not ",
PMLC_GET_AVAIL(tp->t_state) ? "" : "un",
PMLC_GET_MAND(tp->t_state) ? "mand" : "adv",
PMLC_GET_ON(tp->t_state) ? "on" : "off");
fprintf(stderr, " delta: %ld usec",
(long)1000 * tp->t_delta.tv_sec + tp->t_delta.tv_usec);
fprintf(stderr, " numpmid: %d\n", tp->t_numpmid);
for (i = 0; i < tp->t_numpmid; i++) {
fprintf(stderr, " %s (%s):\n", pmIDStr(tp->t_pmidlist[i]), tp->t_namelist[i]);
}
__pmOptFetchDump(stderr, tp->t_fetch);
}
}
#endif
if (!primary && tasklist == NULL && !linger) {
fprintf(stderr, "Nothing to log, and not the primary logger instance ... good-bye\n");
exit(1);
}
if ((sts = __pmLogCreate(pmcd_host, archBase, archive_version, &logctl)) < 0) {
fprintf(stderr, "__pmLogCreate: %s\n", pmErrStr(sts));
exit(1);
}
else {
/*
* try and establish $TZ from the remote PMCD ...
* Note the label record has been set up, but not written yet
*/
char *name = "pmcd.timezone";
pmID pmid;
pmResult *resp;
__pmtimevalNow(&epoch);
sts = pmUseContext(ctx);
if (sts >= 0)
sts = pmLookupName(1, &name, &pmid);
if (sts >= 0)
sts = pmFetch(1, &pmid, &resp);
if (sts >= 0) {
if (resp->vset[0]->numval > 0) { /* pmcd.timezone present */
strcpy(logctl.l_label.ill_tz, resp->vset[0]->vlist[0].value.pval->vbuf);
/* prefer to use remote time to avoid clock drift problems */
epoch = resp->timestamp; /* struct assignment */
if (! use_localtime)
pmNewZone(logctl.l_label.ill_tz);
}
#ifdef PCP_DEBUG
else if (pmDebug & DBG_TRACE_LOG) {
fprintf(stderr,
"main: Could not get timezone from host %s\n",
pmcd_host);
}
#endif
pmFreeResult(resp);
}
}
/* do ParseTimeWindow stuff for -T */
if (runtime) {
struct timeval res_end; /* time window end */
struct timeval start;
struct timeval end;
struct timeval last_delta;
char *err_msg; /* parsing error message */
time_t now;
struct timeval now_tv;
time(&now);
now_tv.tv_sec = now;
now_tv.tv_usec = 0;
start = now_tv;
end.tv_sec = INT_MAX;
end.tv_usec = INT_MAX;
sts = __pmParseTime(runtime, &start, &end, &res_end, &err_msg);
if (sts < 0) {
fprintf(stderr, "%s: illegal -T argument\n%s", pmProgname, err_msg);
exit(1);
}
last_delta = res_end;
tsub(&last_delta, &now_tv);
__pmAFregister(&last_delta, NULL, run_done_callback);
last_stamp = res_end;
}
fprintf(stderr, "Archive basename: %s\n", archBase);
#ifndef IS_MINGW
/* detach yourself from the launching process */
if (isdaemon)
setpgid(getpid(), 0);
#endif
/* set up control port */
init_ports();
__pmFD_ZERO(&fds);
for (i = 0; i < CFD_NUM; ++i) {
if (ctlfds[i] >= 0)
__pmFD_SET(ctlfds[i], &fds);
}
#ifndef IS_MINGW
__pmFD_SET(pmcdfd, &fds);
#endif
if (rsc_fd != -1)
__pmFD_SET(rsc_fd, &fds);
numfds = maxfd() + 1;
if ((sts = do_preamble()) < 0)
fprintf(stderr, "Warning: problem writing archive preamble: %s\n",
pmErrStr(sts));
sts = 0; /* default exit status */
parse_done = 1; /* enable callback processing */
__pmAFunblock();
for ( ; ; ) {
int nready;
#ifdef PCP_DEBUG
if ((pmDebug & DBG_TRACE_APPL2) && (pmDebug & DBG_TRACE_DESPERATE)) {
fprintf(stderr, "before __pmSelectRead(%d,...): run_done_alarm=%d vol_switch_alarm=%d log_alarm=%d\n", numfds, run_done_alarm, vol_switch_alarm, log_alarm);
}
#endif
niter = 0;
while (log_alarm && niter++ < 10) {
__pmAFblock();
log_alarm = 0;
#ifdef PCP_DEBUG
if (pmDebug & DBG_TRACE_APPL2)
fprintf(stderr, "delayed callback: log_alarm\n");
#endif
for (tp = tasklist; tp != NULL; tp = tp->t_next) {
if (tp->t_alarm) {
tp->t_alarm = 0;
do_work(tp);
}
}
__pmAFunblock();
}
if (vol_switch_alarm) {
__pmAFblock();
vol_switch_alarm = 0;
#ifdef PCP_DEBUG
if (pmDebug & DBG_TRACE_APPL2)
fprintf(stderr, "delayed callback: vol_switch_alarm\n");
#endif
newvolume(VOL_SW_TIME);
__pmAFunblock();
}
if (run_done_alarm) {
#ifdef PCP_DEBUG
if (pmDebug & DBG_TRACE_APPL2)
fprintf(stderr, "delayed callback: run_done_alarm\n");
#endif
run_done(0, NULL);
/*NOTREACHED*/
}
__pmFD_COPY(&readyfds, &fds);
nready = __pmSelectRead(numfds, &readyfds, NULL);
#ifdef PCP_DEBUG
if ((pmDebug & DBG_TRACE_APPL2) && (pmDebug & DBG_TRACE_DESPERATE)) {
fprintf(stderr, "__pmSelectRead(%d,...) done: nready=%d run_done_alarm=%d vol_switch_alarm=%d log_alarm=%d\n", numfds, nready, run_done_alarm, vol_switch_alarm, log_alarm);
}
#endif
__pmAFblock();
if (nready > 0) {
/* handle request on control port */
for (i = 0; i < CFD_NUM; ++i) {
if (ctlfds[i] >= 0 && __pmFD_ISSET(ctlfds[i], &readyfds)) {
if (control_req(ctlfds[i])) {
/* new client has connected */
__pmFD_SET(clientfd, &fds);
if (clientfd >= numfds)
numfds = clientfd + 1;
}
}
}
if (clientfd >= 0 && __pmFD_ISSET(clientfd, &readyfds)) {
/* process request from client, save clientfd in case client
* closes connection, resetting clientfd to -1
*/
int fd = clientfd;
if (client_req()) {
/* client closed connection */
__pmFD_CLR(fd, &fds);
__pmCloseSocket(clientfd);
clientfd = -1;
numfds = maxfd() + 1;
qa_case = 0;
}
}
#ifndef IS_MINGW
if (pmcdfd >= 0 && __pmFD_ISSET(pmcdfd, &readyfds)) {
/*
* do not expect this, given synchronous commumication with the
* pmcd ... either pmcd has terminated, or bogus PDU ... or its
* Win32 and we are operating under the different conditions of
* our AF.c implementation there, which has to deal with a lack
* of signal support on Windows - race condition exists between
* this check and the async event timer callback.
*/
__pmPDU *pb;
__pmPDUHdr *php;
sts = __pmGetPDU(pmcdfd, ANY_SIZE, TIMEOUT_NEVER, &pb);
if (sts <= 0) {
if (sts < 0)
fprintf(stderr, "Error: __pmGetPDU: %s\n", pmErrStr(sts));
disconnect(sts);
}
else {
php = (__pmPDUHdr *)pb;
fprintf(stderr, "Error: Unsolicited %s PDU from PMCD\n",
__pmPDUTypeStr(php->type));
disconnect(PM_ERR_IPC);
}
if (sts > 0)
__pmUnpinPDUBuf(pb);
}
#endif
if (rsc_fd >= 0 && __pmFD_ISSET(rsc_fd, &readyfds)) {
/*
* some action on the recording session control fd
* end-of-file means launcher has quit, otherwise we
* expect one of these commands
* V<number>\n - version
* F<folio>\n - folio name
* P<name>\n - launcher's name
* R\n - launcher can replay
* D\n - detach from launcher
* Q\n - quit pmlogger
*/
char rsc_buf[MAXPATHLEN];
char *rp = rsc_buf;
char myc;
int fake_x = 0;
for (rp = rsc_buf; ; rp++) {
if (read(rsc_fd, &myc, 1) <= 0) {
#ifdef PCP_DEBUG
if (pmDebug & DBG_TRACE_APPL2)
fprintf(stderr, "recording session control: eof\n");
#endif
if (rp != rsc_buf) {
*rp = '\0';
fprintf(stderr, "Error: incomplete recording session control message: \"%s\"\n", rsc_buf);
}
fake_x = 1;
break;
}
if (rp >= &rsc_buf[MAXPATHLEN]) {
fprintf(stderr, "Error: absurd recording session control message: \"%100.100s ...\"\n", rsc_buf);
fake_x = 1;
break;
}
if (myc == '\n') {
*rp = '\0';
break;
}
*rp = myc;
}
#ifdef PCP_DEBUG
if (pmDebug & DBG_TRACE_APPL2) {
if (fake_x == 0)
fprintf(stderr, "recording session control: \"%s\"\n", rsc_buf);
}
#endif
if (fake_x)
do_dialog('X');
else if (strcmp(rsc_buf, "Q") == 0 ||
strcmp(rsc_buf, "D") == 0 ||
strcmp(rsc_buf, "?") == 0)
do_dialog(rsc_buf[0]);
else if (rsc_buf[0] == 'F')
folio_name = strdup(&rsc_buf[1]);
else if (rsc_buf[0] == 'P')
rsc_prog = strdup(&rsc_buf[1]);
else if (strcmp(rsc_buf, "R") == 0)
rsc_replay = 1;
else if (rsc_buf[0] == 'V' && rsc_buf[1] == '0') {
/*
* version 0 of the recording session control ...
* this is all we grok at the moment
*/
;
}
else {
fprintf(stderr, "Error: illegal recording session control message: \"%s\"\n", rsc_buf);
do_dialog('X');
}
}
}
else if (vol_switch_flag) {
newvolume(VOL_SW_SIGHUP);
vol_switch_flag = 0;
}
else if (nready < 0 && neterror() != EINTR)
fprintf(stderr, "Error: select: %s\n", netstrerror());
__pmAFunblock();
if (target_pid && !__pmProcessExists(target_pid))
exit(EXIT_SUCCESS);
if (exit_code)
break;
}
exit(exit_code);
}
int
main(int argc, char **argv)
{
int c;
int i;
int sts;
int errflag = 0;
int type = 0;
int verbose = 0;
char *host = NULL; /* pander to gcc */
int mode = PM_MODE_INTERP; /* mode for archives */
char *configfile = NULL;
char *start = NULL;
char *finish = NULL;
char *align = NULL;
char *offset = NULL;
char *logfile = NULL;
pmLogLabel label; /* get hostname for archives */
int zflag = 0; /* for -z */
char *tz = NULL; /* for -Z timezone */
int tzh; /* initial timezone handle */
char local[MAXHOSTNAMELEN];
char *pmnsfile = PM_NS_DEFAULT;
int samples = -1;
double delta = 1.0;
char *endnum;
struct timeval startTime;
struct timeval endTime;
struct timeval appStart;
struct timeval appEnd;
struct timeval appOffset;
pmSetProgname(argv[0]);
while ((c = getopt(argc, argv, "a:A:c:D:h:l:Ln:O:s:S:t:T:U:VzZ:?")) != EOF) {
switch (c) {
case 'a': /* archive name */
if (type != 0) {
fprintf(stderr, "%s: at most one of -a, -h, -L and -U allowed\n", pmGetProgname());
errflag++;
}
type = PM_CONTEXT_ARCHIVE;
host = optarg;
break;
case 'A': /* time alignment */
align = optarg;
break;
case 'c': /* configfile */
if (configfile != NULL) {
fprintf(stderr, "%s: at most one -c option allowed\n", pmGetProgname());
errflag++;
}
configfile = optarg;
break;
case 'D': /* debug options */
sts = pmSetDebug(optarg);
if (sts < 0) {
fprintf(stderr, "%s: unrecognized debug options specification (%s)\n",
pmGetProgname(), optarg);
errflag++;
}
break;
case 'h': /* contact PMCD on this hostname */
if (type != 0) {
fprintf(stderr, "%s: at most one of -a, -h, -L and -U allowed\n", pmGetProgname());
errflag++;
}
host = optarg;
type = PM_CONTEXT_HOST;
break;
case 'L': /* LOCAL, no PMCD */
if (type != 0) {
fprintf(stderr, "%s: at most one of -a, -h, -L and -U allowed\n", pmGetProgname());
errflag++;
}
host = NULL;
type = PM_CONTEXT_LOCAL;
putenv("PMDA_LOCAL_PROC="); /* if proc PMDA needed */
putenv("PMDA_LOCAL_SAMPLE="); /* if sampledso PMDA needed */
break;
case 'l': /* logfile */
logfile = optarg;
break;
case 'n': /* alternative name space file */
pmnsfile = optarg;
break;
case 'O': /* sample offset time */
offset = optarg;
break;
case 's': /* sample count */
samples = (int)strtol(optarg, &endnum, 10);
if (*endnum != '\0' || samples < 0) {
fprintf(stderr, "%s: -s requires numeric argument\n", pmGetProgname());
errflag++;
}
break;
case 'S': /* start time */
start = optarg;
break;
case 't': /* delta seconds (double) */
delta = strtod(optarg, &endnum);
if (*endnum != '\0' || delta <= 0.0) {
fprintf(stderr, "%s: -t requires floating point argument\n", pmGetProgname());
errflag++;
}
break;
case 'T': /* terminate time */
finish = optarg;
break;
case 'U': /* uninterpolated archive log */
if (type != 0) {
fprintf(stderr, "%s: at most one of -a, -h, -L and -U allowed\n", pmGetProgname());
errflag++;
}
type = PM_CONTEXT_ARCHIVE;
mode = PM_MODE_FORW;
host = optarg;
break;
case 'V': /* verbose */
verbose++;
break;
case 'z': /* timezone from host */
if (tz != NULL) {
fprintf(stderr, "%s: at most one of -Z and/or -z allowed\n", pmGetProgname());
errflag++;
}
zflag++;
break;
case 'Z': /* $TZ timezone */
if (zflag) {
fprintf(stderr, "%s: at most one of -Z and/or -z allowed\n", pmGetProgname());
errflag++;
}
tz = optarg;
break;
case '?':
default:
errflag++;
break;
}
}
if (zflag && type == 0) {
fprintf(stderr, "%s: -z requires an explicit -a, -h or -U option\n", pmGetProgname());
errflag++;
}
if (errflag) {
fprintf(stderr,
"Usage: %s options ...\n\
\n\
Options\n\
-a archive metrics source is an archive log\n\
-A align time alignment\n\
-c configfile file to load configuration from\n\
-D debug standard PCP debug options\n\
-h host metrics source is PMCD on host\n\
-l logfile redirect diagnostics and trace output\n\
-L use local context instead of PMCD\n\
-n pmnsfile use an alternative PMNS\n\
-O offset offset sample time\n\
-s samples terminate after this many iterations\n\
-S start start at this time\n\
-t delta sample interval in seconds(float) [default 1.0]\n\
-T finish finish at this time\n\
-U archive metrics source is an uninterpolated archive log\n\
-V verbose/diagnostic output\n\
-z set reporting timezone to local time for host from -a, -h or -U\n\
-Z timezone set reporting timezone\n",
pmGetProgname());
exit(1);
}
if (logfile != NULL) {
pmOpenLog(pmGetProgname(), logfile, stderr, &sts);
if (sts < 0) {
fprintf(stderr, "%s: Could not open logfile \"%s\"\n", pmGetProgname(), logfile);
}
}
if (pmnsfile != PM_NS_DEFAULT && (sts = pmLoadNameSpace(pmnsfile)) < 0) {
printf("%s: Cannot load namespace from \"%s\": %s\n", pmGetProgname(),
pmnsfile, pmErrStr(sts));
exit(1);
}
if (type == 0) {
type = PM_CONTEXT_HOST;
gethostname(local, sizeof(local));
host = local;
}
if ((sts = pmNewContext(type, host)) < 0) {
if (type == PM_CONTEXT_HOST)
fprintf(stderr, "%s: Cannot connect to PMCD on host \"%s\": %s\n",
pmGetProgname(), host, pmErrStr(sts));
else
fprintf(stderr, "%s: Cannot open archive \"%s\": %s\n",
pmGetProgname(), host, pmErrStr(sts));
exit(1);
}
if (type == PM_CONTEXT_ARCHIVE) {
if ((sts = pmGetArchiveLabel(&label)) < 0) {
fprintf(stderr, "%s: Cannot get archive label record: %s\n",
pmGetProgname(), pmErrStr(sts));
exit(1);
}
if (mode != PM_MODE_INTERP) {
if ((sts = pmSetMode(mode, &label.ll_start, 0)) < 0) {
fprintf(stderr, "%s: pmSetMode: %s\n", pmGetProgname(), pmErrStr(sts));
exit(1);
}
}
startTime = label.ll_start;
sts = pmGetArchiveEnd(&endTime);
if (sts < 0) {
fprintf(stderr, "%s: pmGetArchiveEnd: %s\n", pmGetProgname(),
pmErrStr(sts));
exit(1);
}
}
else {
gettimeofday(&startTime, NULL);
endTime.tv_sec = INT_MAX;
}
if (zflag) {
if ((tzh = pmNewContextZone()) < 0) {
fprintf(stderr, "%s: Cannot set context timezone: %s\n",
pmGetProgname(), pmErrStr(tzh));
exit(1);
}
if (type == PM_CONTEXT_ARCHIVE)
printf("Note: timezone set to local timezone of host \"%s\" from archive\n\n",
label.ll_hostname);
else
printf("Note: timezone set to local timezone of host \"%s\"\n\n", host);
}
else if (tz != NULL) {
if ((tzh = pmNewZone(tz)) < 0) {
fprintf(stderr, "%s: Cannot set timezone to \"%s\": %s\n",
pmGetProgname(), tz, pmErrStr(tzh));
exit(1);
}
printf("Note: timezone set to \"TZ=%s\"\n\n", tz);
}
else
tzh = pmNewContextZone();
/* non-flag args are argv[optind] ... argv[argc-1] */
while (optind < argc) {
printf("extra argument[%d]: %s\n", optind, argv[optind]);
optind++;
}
if (align != NULL && type != PM_CONTEXT_ARCHIVE) {
fprintf(stderr, "%s: -A option only supported for PCP archives, alignment request ignored\n",
pmGetProgname());
align = NULL;
}
sts = pmParseTimeWindow(start, finish, align, offset, &startTime,
&endTime, &appStart, &appEnd, &appOffset,
&endnum);
if (sts < 0) {
fprintf(stderr, "%s: %s\n", pmGetProgname(), endnum);
exit(1);
}
if ((sts = pmLookupName(2, namelist, pmidlist)) < 0) {
fprintf(stderr, "%s: pmLookupName failed: %s\n", pmGetProgname(), pmErrStr(sts));
exit(1);
}
/* goto the start */
if ((sts = pmSetMode(PM_MODE_INTERP, &appStart, (int)(delta * 1000))) < 0) {
fprintf(stderr, "%s: pmSetMode failed: %s\n", pmGetProgname(), pmErrStr(sts));
exit(1);
}
pmCtime(&appStart.tv_sec, timebuf);
printf("archive %s\nstartTime: %19.19s.%06d\n",
host, timebuf, (int)appStart.tv_usec);
pmCtime(&appEnd.tv_sec, timebuf);
printf("endTime : %19.19s.%06d\nsamples=%d delta=%dms\n",
timebuf, (int)appEnd.tv_usec, samples, (int)(delta * 1000));
/* play forwards over the mark */
for (i=0; i < samples; i++) {
if ((sts = pmFetch(2, pmidlist, &result)) < 0) {
fprintf(stderr, "%s: pmFetch failed: %s\n", pmGetProgname(), pmErrStr(sts));
exit(1);
}
check_result("forwards ", result);
curpos = result->timestamp; /* struct cpy */
pmFreeResult(result);
}
/* rewind back over the mark */
if ((sts = pmSetMode(PM_MODE_INTERP, &curpos, (int)(delta * -1000))) < 0) {
fprintf(stderr, "%s: pmSetMode failed: %s\n", pmGetProgname(), pmErrStr(sts));
exit(1);
}
for (i=0; i < samples; i++) {
if ((sts = pmFetch(2, pmidlist, &result)) < 0) {
fprintf(stderr, "%s: pmFetch failed: %s\n", pmGetProgname(), pmErrStr(sts));
exit(1);
}
check_result("rewinding", result);
pmFreeResult(result);
}
return 0;
}