int
chk_one(task_t *tp, pmID pmid, int inst)
{
optreq_t *rqp;
task_t *ctp;
rqp = findoptreq(pmid, inst);
if (rqp == NULL)
return 0;
ctp = rqp->r_fetch->f_aux;
if (ctp == NULL || ctp == tp)
/*
* can only happen if same metric+inst appears more than once
* in the same group ... this can never be a conflict
*/
return 1;
if (PMLC_GET_MAND(ctp->t_state)) {
if (PMLC_GET_ON(ctp->t_state)) {
if (PMLC_GET_MAND(tp->t_state) == 0 && PMLC_GET_MAYBE(tp->t_state) == 0) {
if (PMLC_GET_ON(tp->t_state))
return -1;
else
return -2;
}
}
else {
if (PMLC_GET_MAND(tp->t_state) == 0 && PMLC_GET_MAYBE(tp->t_state) == 0) {
if (PMLC_GET_ON(tp->t_state))
return -3;
else
return -4;
}
}
/*
* new mandatory, over-rides the old mandatory
*/
undo(ctp, rqp, inst);
}
else {
/*
* new anything, over-rides the old advisory
*/
undo(ctp, rqp, inst);
}
return 0;
}
/* Return true if a request for a new logging state (newstate) will be honoured
* when current state is curstate.
*/
static int
update_ok(int curstate, int newstate)
{
/* If new state is advisory and current is mandatory, reject request.
* Any new mandatory state is accepted. If the new state is advisory
* and the current state is advisory, it is accepted.
* Note that a new state of maybe (mandatory maybe) counts as mandatory
*/
if (PMLC_GET_MAND(newstate) == 0 && PMLC_GET_MAYBE(newstate) == 0 &&
PMLC_GET_MAND(curstate))
return 0;
else
return 1;
}
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;
}
/* Update an existing metric (given a pmValueSet) adding it to the specified
* task. Allocate and return a new task_t if the specified task pointer is nil.
*/
static int
update_metric(pmValueSet *vsp, int reqstate, int mflags, task_t **result)
{
pmID pmid = vsp->pmid;
task_t *ntp = *result; /* pointer to new task */
task_t *ctp; /* pointer to current task */
optreq_t *rqp;
pmDesc *dp;
int i, j, inst;
int sts, need = 0;
int addpmid = 0;
int freedp;
/* allocate a new task if null task pointer passed in */
if (ntp == NULL) {
ntp = calloc(1, sizeof(task_t));
if (ntp == NULL) {
__pmNoMem("update_metric: new task calloc", sizeof(task_t),
PM_FATAL_ERR);
}
*result = ntp;
}
if ((mflags & MF_HAS_INDOM) == 0) {
rqp = findoptreq(pmid, 0);
ctp = (task_t *)(rqp->r_fetch->f_aux);
if (!update_ok(ctp->t_state, reqstate))
return 1;
/* if the new state is advisory off, just remove the metric */
if ((PMLC_GET_MAYBE(reqstate)) ||
(PMLC_GET_MAND(reqstate) == 0 && PMLC_GET_ON(reqstate) == 0))
del_optreq(rqp);
else {
/* update the optreq. For single valued metrics there are no
* instances involved so the sole optreq can just be re-used.
*/
if ((sts = __pmOptFetchDel(&ctp->t_fetch, rqp)) < 0)
die("update_metric: 1 metric __pmOptFetchDel", sts);
__pmOptFetchAdd(&ntp->t_fetch, rqp);
linkback(ntp);
addpmid = 1;
}
}
else {
/* metric has an instance domain */
if (vsp->numval > 0) {
/* tricky: since optFetch can't handle instance profiles of the
* form "all except these specific instances", and managing it
* manually is just too hard, reject requests for specific
* metric instances if "all instances" of the metric are already
* being logged.
* Note: advisory off "all instances" is excepted since ANY request
* overrides and advisory off. E.g. "advisory off all" followed by
* "advisory on someinsts" turns on advisory logging for
* "someinsts". mflags will be zero for "advisory off" metrics.
*/
if (mflags & MF_HAS_ALL)
return 1; /* can't turn "all" into specific insts */
for (i = 0; i < vsp->numval; i++) {
dp = NULL;
freedp = 0;
inst = vsp->vlist[i].inst;
rqp = findoptreq(pmid, inst);
if (rqp != NULL) {
dp = rqp->r_desc;
ctp = (task_t *)(rqp->r_fetch->f_aux);
/* no work required if new task and current are the same */
if (ntp == ctp)
continue;
if (!update_ok(ctp->t_state, reqstate))
continue;
/* remove inst's group from current task */
if ((sts = __pmOptFetchDel(&ctp->t_fetch, rqp)) < 0)
die("update_metric: instance add __pmOptFetchDel", sts);
/* put group back if there are any instances left */
if (rqp->r_numinst > 1) {
/* remove inst from group */
for (j = 0; j < rqp->r_numinst; j++)
if (inst == rqp->r_instlist[j])
break;
/* don't call memmove to move zero bytes */
if (j < rqp->r_numinst - 1)
memmove(&rqp->r_instlist[j], &rqp->r_instlist[j+1],
(rqp->r_numinst - 1 - j) *
sizeof(rqp->r_instlist[0]));
rqp->r_numinst--;
/* (don't bother realloc-ing the instlist to a smaller size) */
__pmOptFetchAdd(&ctp->t_fetch, rqp);
linkback(ctp);
/* no need to update hash list, rqp already there */
}
/* if that was the last instance, free the group */
else {
if (( sts = __pmHashDel(pmid, (void *)rqp, &pm_hash)) < 0)
die("update_metric: instance __pmHashDel", sts);
freedp = 1;
free(rqp->r_instlist);
free(rqp);
}
}
/* advisory off (mandatory maybe) metrics don't get put into
* the data structure
*/
if (PMLC_GET_MAYBE(reqstate) ||
(PMLC_GET_MAND(reqstate) == 0 && PMLC_GET_ON(reqstate) == 0)) {
if (freedp)
free(dp);
continue;
}
addpmid = 1;
/* try to find an existing optreq_t for the instance */
rqp = find_instoptreq(ntp, pmid);
if (rqp != NULL) {
if ((sts = __pmOptFetchDel(&ntp->t_fetch, rqp)) < 0)
die("update_metric: instance add __pmOptFetchDel", sts);
}
/* no existing optreq_t found, allocate & populate a new one */
else {
rqp = (optreq_t *)calloc(1, sizeof(optreq_t));
if (rqp == NULL) {
__pmNoMem("update_metric: optreq calloc",
sizeof(optreq_t), PM_FATAL_ERR);
}
/* if the metric existed but the instance didn't, we don't
* have a valid pmDesc (dp), so find one.
*/
if (dp == NULL) {
/* find metric and associated pmDesc */
__pmHashNode *hp;
for (hp = __pmHashSearch(pmid, &pm_hash);
hp != NULL; hp = hp->next) {
if (pmid == (pmID)hp->key)
break;
}
assert(hp != NULL);
dp = ((optreq_t *)hp->data)->r_desc;
}
/* recycle pmDesc from the old group, if possible */
if (freedp) {
rqp->r_desc = dp;
freedp = 0;
}
/* otherwise allocate & copy a new pmDesc via dp */
else {
need = sizeof(pmDesc);
rqp->r_desc = (pmDesc *)malloc(need);
if (rqp->r_desc == NULL) {
__pmNoMem("update_metric: new inst pmDesc malloc",
need, PM_FATAL_ERR);
}
memcpy(rqp->r_desc, dp, need);
}
if ((sts = __pmHashAdd(pmid, (void *)rqp, &pm_hash)) < 0)
die("update_metric: __pmHashAdd", sts);
}
need = (rqp->r_numinst + 1) * sizeof(rqp->r_instlist[0]);
rqp->r_instlist = (int *)realloc(rqp->r_instlist, need);
if (rqp->r_instlist == NULL) {
__pmNoMem("update_metric: inst list resize", need,
PM_FATAL_ERR);
}
rqp->r_instlist[rqp->r_numinst++] = inst;
__pmOptFetchAdd(&ntp->t_fetch, rqp);
linkback(ntp);
if (freedp)
free(dp);
}
}
/* the vset has numval == 0, a request for "all instances" */
else {
/* if the metric is a singular instance that has mandatory logging
* or has at least one instance with mandatory logging on, a
* request for advisory logging cannot be honoured
*/
if ((mflags & MF_HAS_MAND) &&
PMLC_GET_MAND(reqstate) == 0 && PMLC_GET_MAYBE(reqstate) == 0)
return 1;
if (mflags & MF_HAS_ALL) {
/* if there is an "all instances" for the metric, it will be
* the only optreq_t for the metric
*/
rqp = findoptreq(pmid, 0);
ctp = (task_t *)rqp->r_fetch->f_aux;
/* if the metric is "advisory on, all instances" and the
* request is for "mandatory maybe, all instances" the current
* advisory logging state of the metric is retained
*/
if (PMLC_GET_MAND(ctp->t_state) == 0 && PMLC_GET_MAYBE(reqstate))
return 0;
/* advisory off & mandatory maybe metrics don't get put into
* the data structure
*/
if (PMLC_GET_MAYBE(reqstate) ||
(PMLC_GET_MAND(reqstate) == 0 && PMLC_GET_ON(reqstate) == 0)) {
del_optreq(rqp);
return 0;
}
addpmid = 1;
if ((sts = __pmOptFetchDel(&ctp->t_fetch, rqp)) < 0)
die("update_metric: all inst __pmOptFetchDel", sts);
/* don't delete from hash list, rqp re-used */
__pmOptFetchAdd(&ntp->t_fetch, rqp);
linkback(ntp);
}
else {
/* there are one or more specific instances for the metric.
* The metric cannot have an "all instances" at the same time.
*
* if the request is for "mandatory maybe, all instances" and
* the only instances of the metric all have advisory logging
* on, retain the current advisory semantics.
*/
if (PMLC_GET_MAYBE(reqstate) &&
(mflags & MF_HAS_INST) && !(mflags & MF_HAS_MAND))
return 0;
dp = del_insts(pmid);
/* advisory off (mandatory maybe) metrics don't get put into
* the data structure
*/
if (PMLC_GET_MAYBE(reqstate) ||
(PMLC_GET_MAND(reqstate) == 0 && PMLC_GET_ON(reqstate) == 0)) {
free(dp);
return 0;
}
addpmid = 1;
rqp = (optreq_t *)calloc(1, sizeof(optreq_t));
if (rqp == NULL) {
__pmNoMem("update_metric: all inst calloc",
sizeof(optreq_t), PM_FATAL_ERR);
}
rqp->r_desc = dp;
__pmOptFetchAdd(&ntp->t_fetch, rqp);
linkback(ntp);
if ((sts = __pmHashAdd(pmid, (void *)rqp, &pm_hash)) < 0)
die("update_metric: all inst __pmHashAdd", sts);
}
}
}
if (!addpmid)
return 0;
/* add pmid to new task if not already there */
for (i = 0; i < ntp->t_numpmid; i++)
if (pmid == ntp->t_pmidlist[i])
break;
if (i >= ntp->t_numpmid) {
pmDesc desc;
char *name;
int need;
if ((sts = pmLookupDesc(pmid, &desc)) < 0)
die("update_metric: cannot lookup desc", sts);
if ((sts = pmNameID(pmid, &name)) < 0)
die("update_metric: cannot lookup name", sts);
need = (ntp->t_numpmid + 1) * sizeof(pmID);
if (!(ntp->t_pmidlist = (pmID *)realloc(ntp->t_pmidlist, need)))
__pmNoMem("update_metric: grow task pmidlist", need, PM_FATAL_ERR);
need = (ntp->t_numpmid + 1) * sizeof(char *);
if (!(ntp->t_namelist = (char **)realloc(ntp->t_namelist, need)))
__pmNoMem("update_metric: grow task namelist", need, PM_FATAL_ERR);
need = (ntp->t_numpmid + 1) * sizeof(pmDesc);
if (!(ntp->t_desclist = (pmDesc *)realloc(ntp->t_desclist, need)))
__pmNoMem("update_metric: grow task desclist", need, PM_FATAL_ERR);
i = ntp->t_numpmid;
ntp->t_pmidlist[i] = pmid;
ntp->t_namelist[i] = name;
ntp->t_desclist[i] = desc;
ntp->t_numpmid++;
}
return 0;
}
