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; }