void RarArchEngine::remove_temp_dir() {
if (temp_dir != NULL) delete temp_dir;
temp_dir = NULL;
disconnect(this,SIGNAL(update_ok()),this,SLOT(remove_temp_dir()));
disconnect(this,SIGNAL(create_ok()),this,SLOT(remove_temp_dir()));
disconnect(this,SIGNAL(extraction_ok()),this,SLOT(extraction_ok()));
disconnect(this,SIGNAL(error(const QString &)),this,SLOT(remove_temp_dir()));
}
/* 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;
}
