int
main(int argc, char **argv)
{
char *p;
struct timeval delta = { 1, 0 };
if (argc != 2) _usage();
__pmAFregister(&delta, NULL, timeout);
#ifdef DBG_TRACE_DESPERATE
pmDebug |= DBG_TRACE_DESPERATE;
#endif
for (p = argv[1]; *p; p++) {
switch (*p) {
case 'i':
fprintf(stderr, "initialize\n");
PM_INIT_LOCKS();
break;
case 'l':
fprintf(stderr, "lock\n");
PM_LOCK(__pmLock_libpcp);
break;
case 'u':
fprintf(stderr, "unlock\n");
PM_UNLOCK(__pmLock_libpcp);
break;
default:
_usage();
}
}
return 0;
}
void
loggerMain(pmdaInterface *dispatch)
{
fd_set readyfds;
int nready, pmcdfd;
pmcdfd = __pmdaInFd(dispatch);
if (pmcdfd > maxfd)
maxfd = pmcdfd;
FD_ZERO(&fds);
FD_SET(pmcdfd, &fds);
/* arm interval timer */
if (__pmAFregister(&interval, NULL, logger_timer) < 0) {
__pmNotifyErr(LOG_ERR, "registering event interval handler");
exit(1);
}
for (;;) {
memcpy(&readyfds, &fds, sizeof(readyfds));
nready = select(maxfd+1, &readyfds, NULL, NULL, NULL);
if (pmDebug & DBG_TRACE_APPL2)
__pmNotifyErr(LOG_DEBUG, "select: nready=%d interval=%d",
nready, interval_expired);
if (nready < 0) {
if (neterror() != EINTR) {
__pmNotifyErr(LOG_ERR, "select failure: %s", netstrerror());
exit(1);
} else if (!interval_expired) {
continue;
}
}
__pmAFblock();
if (nready > 0 && FD_ISSET(pmcdfd, &readyfds)) {
if (pmDebug & DBG_TRACE_APPL0)
__pmNotifyErr(LOG_DEBUG, "processing pmcd PDU [fd=%d]", pmcdfd);
if (__pmdaMainPDU(dispatch) < 0) {
__pmAFunblock();
exit(1); /* fatal if we lose pmcd */
}
if (pmDebug & DBG_TRACE_APPL0)
__pmNotifyErr(LOG_DEBUG, "completed pmcd PDU [fd=%d]", pmcdfd);
}
if (interval_expired) {
interval_expired = 0;
event_refresh();
}
__pmAFunblock();
}
}
static int
papi_setup_auto_af(void)
{
if (auto_enable_afid >= 0)
__pmAFunregister(auto_enable_afid);
auto_enable_afid = -1;
if (auto_enable_time) {
struct timeval t;
t.tv_sec = (time_t) auto_enable_time;
t.tv_usec = 0;
auto_enable_afid = __pmAFregister(&t, NULL, auto_enable_expiry_cb);
return auto_enable_afid < 0 ? auto_enable_afid : 0;
}
return 0;
}
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
newvolume(int vol_switch_type)
{
FILE *newfp;
int nextvol = logctl.l_curvol + 1;
time_t now;
static char *vol_sw_strs[] = {
"SIGHUP", "pmlc request", "sample counter",
"sample byte size", "sample time", "max data volume size"
};
vol_samples_counter = 0;
vol_bytes += ftell(logctl.l_mfp);
if (exit_bytes != -1) {
if (vol_bytes >= exit_bytes)
run_done(0, "Byte limit reached");
}
/*
* If we are not part of a callback but instead a
* volume switch from "pmlc" or a "SIGHUP" then
* get rid of pending volume switch in event queue
* as it will now be wrong, and schedule a new
* volume switch event.
*/
if (vol_switch_afid >= 0 && vol_switch_type != VOL_SW_TIME) {
__pmAFunregister(vol_switch_afid);
vol_switch_afid = __pmAFregister(&vol_switch_time, NULL,
vol_switch_callback);
}
if ((newfp = __pmLogNewFile(archBase, nextvol)) != NULL) {
if (logctl.l_state == PM_LOG_STATE_NEW) {
/*
* nothing has been logged as yet, force out the label records
*/
__pmtimevalNow(&last_stamp);
logctl.l_label.ill_start.tv_sec = (__int32_t)last_stamp.tv_sec;
logctl.l_label.ill_start.tv_usec = (__int32_t)last_stamp.tv_usec;
logctl.l_label.ill_vol = PM_LOG_VOL_TI;
__pmLogWriteLabel(logctl.l_tifp, &logctl.l_label);
logctl.l_label.ill_vol = PM_LOG_VOL_META;
__pmLogWriteLabel(logctl.l_mdfp, &logctl.l_label);
logctl.l_label.ill_vol = 0;
__pmLogWriteLabel(logctl.l_mfp, &logctl.l_label);
logctl.l_state = PM_LOG_STATE_INIT;
}
#if 0
if (last_stamp.tv_sec != 0) {
__pmTimeval tmp;
tmp.tv_sec = (__int32_t)last_stamp.tv_sec;
tmp.tv_usec = (__int32_t)last_stamp.tv_usec;
__pmLogPutIndex(&logctl, &tmp);
}
#endif
fclose(logctl.l_mfp);
logctl.l_mfp = newfp;
logctl.l_label.ill_vol = logctl.l_curvol = nextvol;
__pmLogWriteLabel(logctl.l_mfp, &logctl.l_label);
time(&now);
fprintf(stderr, "New log volume %d, via %s at %s",
nextvol, vol_sw_strs[vol_switch_type], ctime(&now));
return nextvol;
}
else
return -oserror();
}
static int
do_control(__pmPDU *pb)
{
int sts;
int control;
int state;
int delta;
pmResult *request;
pmResult *result;
int siamised = 0; /* the verb from siamese (as in twins) */
int i;
int j;
int val;
pmValueSet *vsp;
optreq_t *rqp;
task_t *tp;
time_t now;
int reqstate = 0;
/*
* TODO - encoding for logging interval in requests and results?
*/
if ((sts = __pmDecodeLogControl(pb, &request, &control, &state, &delta)) < 0)
return sts;
#ifdef PCP_DEBUG
if (pmDebug & DBG_TRACE_LOG) {
fprintf(stderr, "do_control: control=%d state=%d delta=%d request ...\n",
control, state, delta);
dumpcontrol(stderr, request, 0);
}
#endif
if (control == PM_LOG_MANDATORY || control == PM_LOG_ADVISORY) {
time(&now);
fprintf(stderr, "\n%s", ctime(&now));
fprintf(stderr, "pmlc request from %s: %s",
pmlc_host, control == PM_LOG_MANDATORY ? "mandatory" : "advisory");
if (state == PM_LOG_ON) {
if (delta == 0)
fprintf(stderr, " on once\n");
else
fprintf(stderr, " on %.1f sec\n", (float)delta/1000);
}
else if (state == PM_LOG_OFF)
fprintf(stderr, " off\n");
else
fprintf(stderr, " maybe\n");
}
/*
* access control checks
*/
sts = 0;
switch (control) {
case PM_LOG_MANDATORY:
if (denyops & PM_OP_LOG_MAND)
sts = PM_ERR_PERMISSION;
break;
case PM_LOG_ADVISORY:
if (denyops & PM_OP_LOG_ADV)
sts = PM_ERR_PERMISSION;
break;
case PM_LOG_ENQUIRE:
/*
* Don't need to check [access] as you have to have _some_
* permission (at least one of PM_OP_LOG_ADV or PM_OP_LOG_MAND
* and PM_OP_LOG_ENQ) to make a connection ... and if you
* have either PM_OP_LOG_ADV or PM_OP_LOG_MAND it makes no
* sense to deny PM_OP_LOG_ENQ operations.
*/
break;
default:
fprintf(stderr, "Bad control PDU type %d\n", control);
sts = PM_ERR_IPC;
break;
}
if (sts < 0) {
fprintf(stderr, "Error: %s\n", pmErrStr(sts));
if ((sts = __pmSendError(clientfd, FROM_ANON, sts)) < 0)
__pmNotifyErr(LOG_ERR,
"do_control: error sending Error PDU to client: %s\n",
pmErrStr(sts));
pmFreeResult(request);
return sts;
}
/* handle everything except PM_LOG_ENQUIRE */
if (control == PM_LOG_MANDATORY || control == PM_LOG_ADVISORY) {
/* update the logging status of metrics */
task_t *newtp = NULL; /* task for metrics/insts in request */
struct timeval tdelta = { 0 };
int newtask;
int mflags;
/* convert state and control to the bitmask used in pmlogger and values
* returned in results. Remember that reqstate starts with nothing on.
*/
if (state == PM_LOG_ON)
PMLC_SET_ON(reqstate, 1);
else
PMLC_SET_ON(reqstate, 0);
if (control == PM_LOG_MANDATORY) {
if (state == PM_LOG_MAYBE)
/* mandatory+maybe => maybe+advisory+off */
PMLC_SET_MAYBE(reqstate, 1);
else
PMLC_SET_MAND(reqstate, 1);
}
/* try to find an existing task for the request
* Never return a "once only" task, it may have gone off already and just
* be hanging around like a bad smell.
*/
if (delta != 0) {
tdelta.tv_sec = delta / 1000;
tdelta.tv_usec = (delta % 1000) * 1000;
newtp = find_task(reqstate, &tdelta);
}
newtask = (newtp == NULL);
for (i = 0; i < request->numpmid; i++) {
vsp = request->vset[i];
if (vsp->numval < 0)
/*
* request is malformed, as we cannot control logging
* for an undefined instance ... there is no way to
* return an error from here, so simply ignore this
* metric
*/
continue;
mflags = find_metric(vsp->pmid);
if (mflags < 0) {
/* only add new metrics if they are ON or MANDATORY OFF
* Careful: mandatory+maybe is mandatory+maybe+off
*/
if (PMLC_GET_ON(reqstate) ||
(PMLC_GET_MAND(reqstate) && !PMLC_GET_MAYBE(reqstate)))
add_metric(vsp, &newtp);
}
else
/* already a specification for this metric */
update_metric(vsp, reqstate, mflags, &newtp);
}
/* schedule new logging task if new metric(s) specified */
if (newtask && newtp != NULL) {
if (newtp->t_fetch == NULL) {
/* the new task ended up with no fetch groups, throw it away */
if (newtp->t_pmidlist != NULL)
free(newtp->t_pmidlist);
free(newtp);
}
else {
/* link new task into tasklist */
newtp->t_next = tasklist;
tasklist = newtp;
/* use only the MAND/ADV and ON/OFF bits of reqstate */
newtp->t_state = PMLC_GET_STATE(reqstate);
if (PMLC_GET_ON(reqstate)) {
newtp->t_delta = tdelta;
newtp->t_afid = __pmAFregister(&tdelta, (void *)newtp,
log_callback);
}
else
newtp->t_delta.tv_sec = newtp->t_delta.tv_usec = 0;
linkback(newtp);
}
}
}
#ifdef PCP_DEBUG
if (pmDebug & DBG_TRACE_APPL0)
dumpit();
#endif
/* just ignore advisory+maybe---the returned pmResult will have the metrics
* in their original state indicating that the request could not be
* satisfied.
*/
result = request;
result->timestamp.tv_sec = result->timestamp.tv_usec = 0; /* for purify */
/* write the current state of affairs into the result _pmResult */
for (i = 0; i < request->numpmid; i++) {
if (control == PM_LOG_MANDATORY || control == PM_LOG_ADVISORY) {
char **names;
sts = pmNameAll(request->vset[i]->pmid, &names);
if (sts < 0)
fprintf(stderr, " metric: %s", pmIDStr(request->vset[i]->pmid));
else {
fprintf(stderr, " metric: ");
__pmPrintMetricNames(stderr, sts, names, " or ");
free(names);
}
}
if (request->vset[i]->numval <= 0 && !siamised) {
result = siamise_request(request);
siamised = 1;
}
/*
* pmids with numval <= 0 in the request have a null vset ptr in the
* in the corresponding place in the siamised result.
*/
if (result->vset[i] != NULL)
vsp = result->vset[i];
else {
/* the result should also contain the history for an all instances
* enquire request. Control requests just get the current indom
* since the user of pmlc really wants to see what's being logged
* now rather than in the past.
*/
vsp = build_vset(request->vset[i]->pmid, control == PM_LOG_ENQUIRE);
result->vset[i] = vsp;
}
vsp->valfmt = PM_VAL_INSITU;
for (j = 0; j < vsp->numval; j++) {
rqp = findoptreq(vsp->pmid, vsp->vlist[j].inst);
val = 0;
if (rqp == NULL) {
PMLC_SET_STATE(val, 0);
PMLC_SET_DELTA(val, 0);
}
else {
tp = rqp->r_fetch->f_aux;
PMLC_SET_STATE(val, tp->t_state);
PMLC_SET_DELTA(val, (tp->t_delta.tv_sec*1000 + tp->t_delta.tv_usec/1000));
}
val |= gethistflags(vsp->pmid, vsp->vlist[j].inst);
vsp->vlist[j].value.lval = val;
if (control == PM_LOG_MANDATORY || control == PM_LOG_ADVISORY) {
int expstate = 0;
int statemask = 0;
int expdelta;
if (rqp != NULL && rqp->r_desc->indom != PM_INDOM_NULL) {
char *p;
if (j == 0)
fputc('\n', stderr);
if (pmNameInDom(rqp->r_desc->indom, vsp->vlist[j].inst, &p) >= 0) {
fprintf(stderr, " instance: %s", p);
free(p);
}
else
fprintf(stderr, " instance: #%d", vsp->vlist[j].inst);
}
else {
/* no pmDesc ... punt */
if (vsp->numval > 1 || vsp->vlist[j].inst != PM_IN_NULL) {
if (j == 0)
fputc('\n', stderr);
fprintf(stderr, " instance: #%d", vsp->vlist[j].inst);
}
}
if (state != PM_LOG_MAYBE) {
if (control == PM_LOG_MANDATORY)
PMLC_SET_MAND(expstate, 1);
else
PMLC_SET_MAND(expstate, 0);
if (state == PM_LOG_ON)
PMLC_SET_ON(expstate, 1);
else
PMLC_SET_ON(expstate, 0);
PMLC_SET_MAND(statemask, 1);
PMLC_SET_ON(statemask, 1);
}
else {
PMLC_SET_MAND(expstate, 0);
PMLC_SET_MAND(statemask, 1);
}
expdelta = PMLC_GET_ON(expstate) ? delta : 0;
if ((PMLC_GET_STATE(val) & statemask) != expstate ||
PMLC_GET_DELTA(val) != expdelta)
fprintf(stderr, " [request failed]");
fputc('\n', stderr);
}
}
}
#ifdef PCP_DEBUG
if (pmDebug & DBG_TRACE_LOG) {
__pmDumpResult(stderr, result);
}
#endif
if ((sts = __pmSendResult(clientfd, FROM_ANON, result)) < 0)
__pmNotifyErr(LOG_ERR,
"do_control: error sending Error PDU to client: %s\n",
pmErrStr(sts));
if (siamised) {
for (i = 0; i < request->numpmid; i++)
if (request->vset[i]->numval <= 0)
free(result->vset[i]);
free(result);
}
pmFreeResult(request);
return 0;
}
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);
}
}
}
