static bool
compare_ (const ImageBuf &A, const ImageBuf &B,
float failthresh, float warnthresh,
ImageBufAlgo::CompareResults &result,
ROI roi, int nthreads)
{
imagesize_t npels = roi.npixels();
imagesize_t nvals = npels * roi.nchannels();
int Achannels = A.nchannels(), Bchannels = B.nchannels();
// Compare the two images.
//
double totalerror = 0;
double totalsqrerror = 0;
result.maxerror = 0;
result.maxx=0, result.maxy=0, result.maxz=0, result.maxc=0;
result.nfail = 0, result.nwarn = 0;
float maxval = 1.0; // max possible value
ImageBuf::ConstIterator<Atype> a (A, roi, ImageBuf::WrapBlack);
ImageBuf::ConstIterator<Btype> b (B, roi, ImageBuf::WrapBlack);
bool deep = A.deep();
// Break up into batches to reduce cancelation errors as the error
// sums become too much larger than the error for individual pixels.
const int batchsize = 4096; // As good a guess as any
for ( ; ! a.done(); ) {
double batcherror = 0;
double batch_sqrerror = 0;
if (deep) {
for (int i = 0; i < batchsize && !a.done(); ++i, ++a, ++b) {
bool warned = false, failed = false; // For this pixel
for (int c = roi.chbegin; c < roi.chend; ++c)
for (int s = 0, e = a.deep_samples(); s < e; ++s) {
compare_value (a, c, a.deep_value(c,s),
b.deep_value(c,s), result, maxval,
batcherror, batch_sqrerror,
failed, warned, failthresh, warnthresh);
}
}
} else { // non-deep
for (int i = 0; i < batchsize && !a.done(); ++i, ++a, ++b) {
bool warned = false, failed = false; // For this pixel
for (int c = roi.chbegin; c < roi.chend; ++c)
compare_value (a, c, c < Achannels ? a[c] : 0.0f,
c < Bchannels ? b[c] : 0.0f,
result, maxval, batcherror, batch_sqrerror,
failed, warned, failthresh, warnthresh);
}
}
totalerror += batcherror;
totalsqrerror += batch_sqrerror;
}
result.meanerror = totalerror / nvals;
result.rms_error = sqrt (totalsqrerror / nvals);
result.PSNR = 20.0 * log10 (maxval / result.rms_error);
return result.nfail == 0;
}
/**
* Returns TRUE if the size test succeded, otherwise FALSE
*/
static int check_size_item(Service_T s, Size_T sl, unsigned long size,
char *report) {
ASSERT(s);
ASSERT(sl);
if(sl->test_changes) {
if(sl->runsize != size) {
snprintf(report, STRLEN, "size was changed for %s", s->path);
/* Set the old size to the new value so we do not report
* this more than once per change */
sl->runsize= size;
return FALSE;
}
} else {
if(compare_value(sl->operator, size, sl->size)) {
snprintf(report, STRLEN,
"size test failed for %s -- current size is %lu B",
s->path, size);
return FALSE;
}
}
DEBUG("'%s' file size check passed [current size=%lu B]\n",
s->name, size);
return TRUE;
}
void
*watch_user_daemon(void)
{
while(1) {
user_head = NULL;
get_all_users();
//show_all_users();
pthread_mutex_lock(&watchlist_mutex_lock);
compare_value();
adjust_watchlist();
pthread_mutex_unlock(&watchlist_mutex_lock);
sleep(2);
}
}
/**
* Returns TRUE if the timestamp test succeded, otherwise FALSE
*/
static int check_timestamp_item(Service_T s, Timestamp_T t, char *report) {
time_t now;
time_t timestamp;
ASSERT(s);
ASSERT(t);
if((int)time(&now) == -1) {
snprintf(report, STRLEN, "can't get actual time");
return FALSE;
}
if(!(timestamp= get_timestamp(s->path, S_IFDIR|S_IFREG))) {
snprintf(report, STRLEN, "can't get timestamp for %s", s->path);
return FALSE;
}
if(t->test_changes) {
if(t->timestamp != timestamp) {
snprintf(report, STRLEN, "timestamp was changed for %s", s->path);
/* Set the old timestamp to the new value so we do not report
* this more than once per change */
t->timestamp= timestamp;
return FALSE;
}
} else {
if(compare_value(t->operator, (int)(now - timestamp), t->time)) {
if(! t->event_handled) {
snprintf(report, STRLEN, "timestamp test failed for %s", s->path);
t->event_handled= TRUE;
return FALSE;
}
} else {
t->event_handled= FALSE;
}
}
DEBUG("'%s' timestamp test passed for %s\n", s->name, s->path);
return TRUE;
}
/**
* Returns TRUE if the proc test succeeded
* otherwise FALSE.
*/
static int check_process_resources(Service_T s, Resource_T pr, char *report) {
ProcInfo_T pi;
int okay= TRUE;
ASSERT(s);
ASSERT(pr);
pi= s->procinfo;
switch(pr->resource_id) {
case RESOURCE_ID_CPU_PERCENT:
if(compare_value(pr->operator, pi->cpu_percent, pr->limit)) {
snprintf(report, STRLEN,
"cpu usage of %.1f%% matches resource limit [cpu usage%s%.1f%%]",
pi->cpu_percent/10.0, operatorshortnames[pr->operator],
pr->limit/10.0);
okay= FALSE;
} else {
DEBUG("'%s' cpu usage check passed [current cpu usage=%.1f%%]\n",
s->name, pi->cpu_percent/10.0);
}
break;
case RESOURCE_ID_MEM_PERCENT:
if(compare_value(pr->operator, pi->mem_percent, pr->limit)) {
snprintf(report, STRLEN,
"mem usage of %.1f%% matches resource limit [mem usage%s%.1f%%]",
pi->mem_percent/10.0, operatorshortnames[pr->operator],
pr->limit/10.0);
okay= FALSE;
} else {
DEBUG("'%s' mem usage check passed [current mem usage=%.1f%%]\n",
s->name, pi->mem_percent/10.0);
}
break;
case RESOURCE_ID_MEM_KBYTE:
if(compare_value(pr->operator, pi->mem_kbyte, pr->limit)) {
snprintf(report, STRLEN,
"mem amount of %ldkB matches resource limit [mem amount%s%ldkB]",
pi->mem_kbyte, operatorshortnames[pr->operator],
pr->limit);
okay= FALSE;
} else {
DEBUG("'%s' mem amount check passed [current mem amount=%ldkB]\n",
s->name, pi->mem_kbyte);
}
break;
case RESOURCE_ID_LOAD1:
if(compare_value(pr->operator, (int)(Run.loadavg[0]*10.0), pr->limit)) {
snprintf(report, STRLEN,
"loadavg(1min) of %.1f matches resource limit "
"[loadavg(1min)%s%.1f]",
Run.loadavg[0], operatorshortnames[pr->operator],
pr->limit/10.0);
okay= FALSE;
} else {
DEBUG("'%s' loadavg(1min) check passed [current loadavg(1min)=%.1f]\n",
s->name, Run.loadavg[0]);
}
break;
case RESOURCE_ID_LOAD5:
if(compare_value(pr->operator, (int)(Run.loadavg[1]*10.0), pr->limit)) {
snprintf(report, STRLEN,
"loadavg(5min) of %.1f matches resource limit "
"[loadavg(5min)%s%.1f]",
Run.loadavg[1], operatorshortnames[pr->operator],
pr->limit/10.0);
okay= FALSE;
} else {
DEBUG("'%s' loadavg(5min) check passed [current loadavg(5min)=%.1f]\n",
s->name, Run.loadavg[1]);
}
break;
case RESOURCE_ID_LOAD15:
if(compare_value(pr->operator, (int)(Run.loadavg[2]*10.0), pr->limit)) {
snprintf(report, STRLEN,
"loadavg(15min) of %.1f matches resource limit "
"[loadavg(15min)%s%.1f]",
Run.loadavg[2], operatorshortnames[pr->operator],
pr->limit/10.0);
okay= FALSE;
} else {
DEBUG("'%s' loadavg(15min) check passed "
"[current loadavg(15min)=%.1f]\n",
s->name, Run.loadavg[2]);
}
break;
case RESOURCE_ID_CHILDREN:
if(compare_value(pr->operator, pi->children, pr->limit)) {
snprintf(report, STRLEN,
"children of %i matches resource limit [children%s%ld]",
pi->children, operatorshortnames[pr->operator],
pr->limit);
okay= FALSE;
} else {
DEBUG("'%s' children check passed [current children=%i]\n",
s->name, pi->children);
}
break;
case RESOURCE_ID_TOTAL_MEM_KBYTE:
if(compare_value(pr->operator, pi->total_mem_kbyte, pr->limit)) {
snprintf(report, STRLEN,
"total mem amount of %ldkB matches resource limit"
" [total mem amount%s%ldkB]",
pi->total_mem_kbyte, operatorshortnames[pr->operator],
pr->limit);
okay= FALSE;
} else {
DEBUG("'%s' total mem amount check passed "
"[current total mem amount=%ldkB]\n",
s->name, pi->total_mem_kbyte);
}
break;
default:
log("'%s' error -- unknown resource ID: [%d]\n", s->name, pr->resource_id);
}
if(okay && pr->cycle > 0) {
pr->cycle--;
} else if(! okay) {
pr->cycle++;
}
if(pr->cycle >= pr->max_cycle) {
return FALSE;
}
return TRUE;
}
/**
* Returns TRUE if the device test succeeded
* otherwise FALSE.
*/
static int check_device_resources(Service_T t, Device_T td, char *report) {
ASSERT(t);
ASSERT(td);
if( (td->limit_percent < 0) && (td->limit_absolute < 0) ) {
log("'%s' error: device limit not set\n", t->name);
return FALSE;
}
switch(td->resource) {
case RESOURCE_ID_INODE:
if(t->devinfo->f_files <= 0) {
DEBUG("'%s' filesystem doesn't support inodes\n", t->name);
return TRUE;
}
if(td->limit_percent >= 0) {
if(compare_value(
td->operator,
100 * (t->devinfo->f_files - t->devinfo->f_filesfree) /
t->devinfo->f_files, td->limit_percent)) {
snprintf(report, STRLEN,
"inode usage %ld%% matches resource limit [inode usage%s%d%%]",
100 * (t->devinfo->f_files - t->devinfo->f_filesfree) /
t->devinfo->f_files,
operatorshortnames[td->operator],
td->limit_percent);
return FALSE;
}
} else {
if(compare_value(td->operator, t->devinfo->f_files -
t->devinfo->f_filesfree, td->limit_absolute)) {
snprintf(report, STRLEN,
"inode usage %ld matches resource limit [inode usage%s%ld]",
t->devinfo->f_files - t->devinfo->f_filesfree,
operatorshortnames[td->operator],
td->limit_absolute);
return FALSE;
}
}
DEBUG("'%s' inode usage check passed [current inode usage=%.1f%%]\n",
t->name,
(float) 100 * (t->devinfo->f_files - t->devinfo->f_filesfree) /
t->devinfo->f_files);
return TRUE;
case RESOURCE_ID_SPACE:
if(td->limit_percent >= 0) {
if(compare_value(
td->operator,
100 * (t->devinfo->f_blocks - t->devinfo->f_blocksfreetotal) /
t->devinfo->f_blocks, td->limit_percent)) {
snprintf(report, STRLEN,
"space usage %ld%% matches resource limit [space usage%s%d%%]",
100*(t->devinfo->f_blocks - t->devinfo->f_blocksfreetotal) /
t->devinfo->f_blocks, operatorshortnames[td->operator],
td->limit_percent);
return FALSE;
}
} else {
if(compare_value(td->operator, t->devinfo->f_blocks -
t->devinfo->f_blocksfreetotal, td->limit_absolute)) {
snprintf(report, STRLEN,
"space usage %ld blocks matches resource limit [space usage%s%ld blocks]",
t->devinfo->f_blocks - t->devinfo->f_blocksfreetotal,
operatorshortnames[td->operator],
td->limit_absolute);
return FALSE;
}
}
DEBUG("'%s' space usage check passed [current space usage=%.1f%%]\n",
t->name,
(float) 100*(t->devinfo->f_blocks - t->devinfo->f_blocksfreetotal) /
t->devinfo->f_blocks);
return TRUE;
default:
log("'%s' error -- unknown resource type: [%d]\n", t->name, td->resource);
return FALSE;
}
}
static int cgc_eval_expression(interp_t *interp, expr_t *expr)
{
const char *s;
int i, t1, t2;
var_t tmp;
#ifdef PATCHED
if (expr == NULL)
return 0;
#endif
switch(expr->op)
{
case OP_CONST_STRING:
if (!set_result_string(interp, cgc_strdup(expr->e_cstring.value)))
return 0;
break;
case OP_CONST_INT:
if (!set_result_number(interp, expr->e_cint.value))
return 0;
break;
case OP_FIELD:
s = cgc_get_field(interp, expr->e_cint.value);
if (s == NULL)
return 0;
if (!set_result_string(interp, cgc_strdup(s)))
return 0;
break;
case OP_FIELD_VAR:
if (!get_number(interp, expr->e_var.name, &i))
return 0;
s = cgc_get_field(interp, i);
if (s == NULL)
return 0;
if (!set_result_string(interp, cgc_strdup(s)))
return 0;
break;
case OP_VAR:
if (!set_result_var(interp, get_var(interp, expr->e_var.name)))
return 0;
break;
case OP_ASSIGN:
if (!cgc_eval_expression(interp, expr->e_binop.rhs))
return 0;
// set lhs to interp->result
if (!cgc_assign_result(interp, expr->e_binop.lhs))
return 0;
break;
case OP_CONDITIONAL:
if (!cgc_eval_expression(interp, expr->e_cond.cond))
return 0;
if (coerce_bool(interp, &interp->result))
{
if (!cgc_eval_expression(interp, expr->e_cond.vtrue))
return 0;
}
else
{
if (!cgc_eval_expression(interp, expr->e_cond.vfalse))
return 0;
}
break;
case OP_OR:
if (!cgc_eval_expression(interp, expr->e_binop.lhs))
return 0;
if (coerce_bool(interp, &interp->result))
{
if (!set_result_number(interp, TRUE))
return 0;
}
else
{
if (!cgc_eval_expression(interp, expr->e_binop.rhs))
return 0;
if (!set_result_number(interp,
coerce_bool(interp, &interp->result) ? TRUE : FALSE))
return 0;
}
break;
case OP_AND:
if (!cgc_eval_expression(interp, expr->e_binop.lhs))
return 0;
if (!coerce_bool(interp, &interp->result))
{
if (!set_result_number(interp, FALSE))
return 0;
}
else
{
if (!cgc_eval_expression(interp, expr->e_binop.rhs))
return 0;
if (!set_result_number(interp,
coerce_bool(interp, &interp->result) ? TRUE : FALSE))
return 0;
}
break;
case OP_MATCH:
case OP_NOT_MATCH:
if (!cgc_do_match(interp, expr->e_binop.lhs, expr->e_binop.rhs))
return 0;
if (expr->op == OP_NOT_MATCH)
interp->result.v_number.value = interp->result.v_number.value == TRUE ? FALSE : TRUE;
break;
case OP_CONST_REGEXP:
if (!cgc_do_match(interp, NULL, expr))
return 0;
break;
case OP_LT:
case OP_GT:
case OP_LTE:
case OP_GTE:
case OP_EQ:
case OP_NEQ:
if (!cgc_eval_expression(interp, expr->e_binop.lhs))
return 0;
move_var(&tmp, &interp->result);
if (!cgc_eval_expression(interp, expr->e_binop.rhs))
return 0;
t1 = compare_value(&tmp, &interp->result);
if ((expr->op == OP_LT && t1 < 0) ||
(expr->op == OP_GT && t1 > 0) ||
(expr->op == OP_LTE && t1 <= 0) ||
(expr->op == OP_GTE && t1 >= 0) ||
(expr->op == OP_EQ && t1 == 0) ||
(expr->op == OP_NEQ && t1 != 0))
{
if (!set_result_number(interp, TRUE))
return 0;
}
else
{
if (!set_result_number(interp, FALSE))
return 0;
}
cgc_free_var(&tmp);
break;
case OP_ADD:
case OP_ASSIGN_ADD:
case OP_SUB:
case OP_ASSIGN_SUB:
case OP_MUL:
case OP_ASSIGN_MUL:
case OP_DIV:
case OP_ASSIGN_DIV:
case OP_MOD:
case OP_ASSIGN_MOD:
if (!cgc_eval_expression(interp, expr->e_binop.lhs))
return 0;
t1 = coerce_number(interp, &interp->result);
if (!cgc_eval_expression(interp, expr->e_binop.rhs))
return 0;
t2 = coerce_number(interp, &interp->result);
if (expr->op == OP_ADD || expr->op == OP_ASSIGN_ADD)
t1 = t1 + t2;
else if (expr->op == OP_SUB || expr->op == OP_ASSIGN_SUB)
t1 = t1 - t2;
else if (expr->op == OP_MUL || expr->op == OP_ASSIGN_MUL)
t1 = t1 * t2;
else if (expr->op == OP_DIV || expr->op == OP_ASSIGN_DIV)
{
if (t2 == 0)
return 0;
t1 = t1 / t2;
}
else if (expr->op == OP_MOD || expr->op == OP_ASSIGN_MOD)
{
if (t2 == 0)
return 0;
t1 = t1 % t2;
}
if (!set_result_number(interp, t1))
return 0;
if (expr->op == OP_ASSIGN_ADD ||
expr->op == OP_ASSIGN_SUB ||
expr->op == OP_ASSIGN_MUL ||
expr->op == OP_ASSIGN_DIV ||
expr->op == OP_ASSIGN_MOD)
{
if (!cgc_assign_result(interp, expr->e_binop.lhs))
return 0;
}
break;
case OP_INC_PRE:
case OP_DEC_PRE:
case OP_INC_POST:
case OP_DEC_POST:
if (!cgc_eval_expression(interp, expr->e_unop.expr))
return 0;
move_var(&tmp, &interp->result);
t1 = coerce_number(interp, &tmp);
if (expr->op == OP_INC_PRE || expr->op == OP_INC_POST)
t2 = t1 + 1;
else
t2 = t1 - 1;
if (!set_result_number(interp, t2))
return 0;
if (!cgc_assign_result(interp, expr->e_unop.expr))
return 0;
if (expr->op == OP_INC_POST || expr->op == OP_DEC_POST)
move_var(&interp->result, &tmp);
else
cgc_free_var(&tmp);
break;
case OP_NEGATE:
case OP_NOT:
if (!cgc_eval_expression(interp, expr->e_unop.expr))
return 0;
t1 = coerce_number(interp, &interp->result);
if (expr->op == OP_NEGATE)
t2 = -t1;
else
t2 = coerce_bool(interp, &interp->result) == TRUE ? FALSE : TRUE;
if (!set_result_number(interp, t2))
return 0;
break;
case OP_CONCAT:
if (!do_concat(interp, expr->e_binop.lhs, expr->e_binop.rhs))
return 0;
break;
default:
return 0;
}
return 1;
}
