void DisassemblerContext::print_exists(const ValuePtr<Exists>& term, bool bracket) {
if (bracket)
*m_output << '(';
*m_output << "exists (";
unsigned n_parameters = term->parameter_types().size();
unsigned parameter_name_base = m_parameter_name_index;
m_parameter_name_index += n_parameters;
boost::format name_formatter("%%%s");
m_parameter_names.push_back(ParameterNameList::value_type());
ParameterNameList::value_type& name_list = m_parameter_names.back();
for (unsigned ii = 0; ii != n_parameters; ++ii) {
if (ii)
*m_output << ", ";
std::string name = str(name_formatter % (parameter_name_base + ii));
*m_output << name << " : ";
print_term(term->parameter_types()[ii], false);
name_list.push_back(name);
}
*m_output << ") > ";
print_term(term->result(), true);
m_parameter_names.pop_back();
m_parameter_name_index = parameter_name_base;
if (bracket)
*m_output << ')';
}
void print_term(int address)
{
int i;
switch(HEAP[address].s1.kind)
{
case REF:
if(HEAP[address].s1.addr == address)
printf("_%d", address);
else
print_term(HEAP[address].s1.addr);
break;
case STR:
address = HEAP[address].s1.addr;
printf("%s", HEAP[address].s2.name);
if(HEAP[address].s2.arity > 0)
{
printf("(");
for(i=0; i<HEAP[address].s2.arity; i++)
{
print_term(address+1+i);
if(i<HEAP[address].s2.arity-1)
printf(", ");
}
printf(")");
}
}
}
static int term_test(IC_Env *env)
{
ETERM *ti, *to, *tr;
ti = erl_format("[{hej, 1, 23}, \"string\", {1.23, 45}]");
fprintf(stdout, "\n======== m_i_term test ======\n\n");
tr = m_i_term_test(NULL, ti, &to, env);
CHECK_EXCEPTION(env);
RETURN_IF_OK(erl_match(ti, to) && erl_match(ti, tr));
if (!erl_match(ti, to)) {
fprintf(stdout, " out parameter error, sent:\n");
print_term(ti);
fprintf(stdout, "got:\n");
print_term(to);
}
if (!erl_match(ti, tr)) {
fprintf(stdout, " result error, sent:\n");
print_term(ti);
fprintf(stdout, "got:\n");
print_term(tr);
}
erl_free_term(ti);
erl_free_term(to);
erl_free_term(tr);
return -1;
}
static int typedef_test(IC_Env *env)
{
m_banan mbi, mbo; /* erlang_port */
m_apa mai; /* ETERM* */
m_apa mao = NULL;
long tl;
strcpy(mbi.node,"node");
mbi.id = 15;
mbi.creation = 1;
fprintf(stdout, "\n======== m_i_typedef test ======\n\n");
mai = erl_format("[{hej, 1, 23}, \"string\", {1.23, 45}]");
tl = m_i_typedef_test(NULL, mai, &mbi, &mao, &mbo, env);
CHECK_EXCEPTION(env);
RETURN_IF_OK(erl_match(mai, mao) && cmp_port(&mbi, &mbo) && tl == 4711);
if (!erl_match(mai, mao)) {
fprintf(stdout, " out parameter error (term), sent:\n");
print_term(mai);
fprintf(stdout, "got:\n");
print_term(mao);
}
if (!cmp_port(&mbi, &mbo)) {
fprintf(stdout, " out parameter error (port), sent:\n");
print_port(&mbi);
fprintf(stdout, "got:\n");
print_port(&mbo);
}
if (tl != 4711) {
fprintf(stdout, " result error, sent: 4711, got %ld\n", tl);
}
erl_free_term(mai);
erl_free_term(mao);
return -1;
}
void DisassemblerContext::print_function_type_term(const ValuePtr<FunctionType>& term, bool bracket, const ValuePtr<Function>& use_names) {
PSI_ASSERT(!use_names || (term->parameter_types().size() == use_names->parameters().size()));
if (bracket)
*m_output << '(';
*m_output << "function";
switch (term->calling_convention()) {
case cconv_c: break;
case cconv_x86_stdcall: *m_output << " cc_x86_stdcall";
case cconv_x86_thiscall: *m_output << " cc_x86_thiscall";
case cconv_x86_fastcall: *m_output << " cc_x86_fastcall";
default: PSI_FAIL("Unknown calling convention in disassembler");
}
if (term->sret())
*m_output << " sret";
*m_output << " (";
unsigned n_parameters = term->parameter_types().size();
unsigned parameter_name_base = m_parameter_name_index;
m_parameter_name_index += n_parameters;
boost::format name_formatter("%%%s");
m_parameter_names.push_back(ParameterNameList::value_type());
ParameterNameList::value_type& name_list = m_parameter_names.back();
for (unsigned ii = 0; ii != n_parameters; ++ii) {
if (ii)
*m_output << ", ";
std::string name;
if (use_names) {
*m_output << TermNamePrinter(&m_names.find(use_names->parameters().at(ii))->second->name);
} else {
*m_output << name_formatter % (parameter_name_base + ii);
}
const ParameterType& ty = term->parameter_types()[ii];
*m_output << " :";
print_parameter_attributes(ty.attributes);
*m_output << ' ';
print_term(ty.value, false);
name_list.push_back(name);
}
*m_output << ") >";
print_parameter_attributes(term->result_type().attributes);
*m_output << ' ';
print_term(term->result_type().value, true);
m_parameter_names.pop_back();
m_parameter_name_index = parameter_name_base;
if (bracket)
*m_output << ')';
}
void DisassemblerContext::print_apply_term(const ValuePtr<ApplyType>& apply, bool bracket) {
if (bracket)
*m_output << '(';
*m_output << "apply ";
print_term(apply->recursive(), true);
for (std::vector<ValuePtr<> >::const_iterator ii = apply->parameters().begin(), ie = apply->parameters().end(); ii != ie; ++ii) {
*m_output << ' ';
print_term(*ii, true);
}
if (bracket)
*m_output << ')';
}
static void
print_variable(Variable *var)
{
GList *itr;
printf("= Variable: %s =\n", var->name);
printf("struct sml_object Variable: %p\n", var->sml_var);
printf("Range %f - %f\n", var->min, var->max);
printf("Current value: %f\n", var->cur_value);
printf("Guess value: %f\n", var->guess_value);
printf("Last event: %p\n", var->last_event);
printf("Terms:\n");
for (itr = var->terms; itr; itr = itr->next) {
print_term(itr->data);
}
printf("Events:\n");
for (itr = var->events; itr; itr = itr->next)
print_event(itr->data);
printf("Status Events:\n");
for (itr = var->status_events; itr; itr = itr->next)
print_status_event(itr->data);
printf("====================\n");
}
void add_stuff(term *t, environment *env)
{
if(t->kind == DEF){
add_environment(env, t);
}
if(t->kind == IND){
term **constructors = t->cases;
t->cases = 0;
int n = t->n;
add_environment(env, t);
int i;
for (i = 0; i < n; ++i) {
term *cons = constructors[i];
evaluate_term(cons, env);
add_environment(env, cons);
}
term *elim = make_eliminator(t, constructors, n);
elim->annotation = type_infer(elim, 0, 0);
printf("Automatically adding %s: ", elim->name);
print_term(elim->annotation);
printf("\n");
add_environment(env, elim);
for (i = 0; i < n; ++i) {
free_term(constructors[i]);
}
free(constructors);
free_term(elim);
}
}
void DisassemblerContext::print_phi_term(const ValuePtr<Phi>& term) {
*m_output << "phi ";
print_term(term->type(), true);
*m_output << ": ";
const std::vector<PhiEdge>& edges = term->edges();
bool first = true;
for (std::vector<PhiEdge>::const_iterator ii = edges.begin(), ie = edges.end(); ii != ie; ++ii) {
if (first)
first = false;
else
*m_output << ", ";
*m_output << name(ii->block) << " > ";
print_term(ii->value, true);
}
*m_output << ";\n";
}
void dump_parse_post_compile(Term* term)
{
std::cout << "dump_parse " << global_id(term) << ": ";
for (int i=0; i < term->numInputs(); i++) {
if (i != 0) std::cout << ", ";
print_term(term->input(0), std::cout);
}
std::cout << std::endl;
}
void blazeit(FILE *input, environment *env)
{
while(1){
if(debug){
printf("~ ");
fflush(stdout);
}
char *line = fgetl(input);
if(!line){
printf("EOF\n");
break;
}
term *t = parse_string(line);
if (!t) continue;
if (debug){
printf("Input: ");
print_term(t);
printf("\n");
}
term *type = type_infer(t, env, 0);
if (debug){
printf("Type Check: ");
print_term(type);
printf("\n");
}
if(!type) fprintf(stderr, "Didn't Type Check!\n");
evaluate_term(t, env);
add_stuff(t, env);
if(debug){
printf("Output: ");
print_term(t);
printf("\n");
}
free_term(type);
free_term(t);
free(line);
}
}
bool command::process(term & t)
{
bool ret = false;
term resp;
#ifdef PRINTCMD
char * tmpbuf = print_term(command);
REMOTE_LOG(DBG, "========================================\nCOMMAND : %s %s\n========================================\n",
CMD_NAME_STR(ERL_INT_VALUE(cmd)),
tmpbuf);
delete tmpbuf;
#endif
if(t.is_tuple() && t[1].is_integer()) {
int cmd = t[1].v.i;
resp.tuple();
resp.add(t[0]);
resp.insert().integer(cmd);
if((t.length() - 1) != (size_t)CMD_ARGS_COUNT(cmd)) {
term & _t = resp.insert().tuple();
_t.insert().atom("error");
_t.insert().atom("badarg");
if(resp.is_undef())
REMOTE_LOG(ERR, "ERROR badarg %s expected %d, got %d\n", CMD_NAME_STR(cmd)
, CMD_ARGS_COUNT(cmd), (t.length() - 1));
if(resp.is_undef()) REMOTE_LOG(CRT, "driver error: no resp generated, shutting down port\n");
vector<unsigned char> respv = tc.encode(resp);
p.write_cmd(respv);
} else {
switch(cmd) {
case RMOTE_MSG: ret = change_log_flag(t, resp); break;
case GET_SESSN: ret = get_session(t, resp); break;
case PUT_SESSN: ret = release_conn(t, resp); break;
case CMT_SESSN: ret = commit(t, resp); break;
case RBK_SESSN: ret = rollback(t, resp); break;
case CMD_DSCRB: ret = describe(t, resp); break;
case PREP_STMT: ret = prep_sql(t, resp); break;
case BIND_ARGS: ret = bind_args(t, resp); break;
case EXEC_STMT: ret = exec_stmt(t, resp); break;
case FTCH_ROWS: ret = fetch_rows(t, resp); break;
case CLSE_STMT: ret = close_stmt(t, resp); break;
case GET_LOBDA: ret = get_lob_data(t, resp); break;
case CMD_ECHOT: ret = echo(t, resp); break;
case SESN_PING: ret = ping(t, resp); break;
default:
ret = true;
break;
}
}
}
return ret;
}
void DisassemblerContext::print_recursive(const ValuePtr<RecursiveType>& term) {
*m_output << "recursive (";
boost::format name_formatter("%%%s");
for (RecursiveType::ParameterList::const_iterator ib = term->parameters().begin(), ii = term->parameters().begin(), ie = term->parameters().end(); ii != ie; ++ii) {
if (ii != ib)
*m_output << ", ";
*m_output << name(*ii) << " : ";
print_term((*ii)->type(), false);
}
*m_output << ") > ";
if (term->result())
print_term(term->result(), true);
else
*m_output << "NULL";
*m_output << ";\n";
}
void log_domain_print_message(const gchar *domain, gchar *buf)
{
gchar *buf_nl;
regex_t regex;
gint ret_comp, ret_exec;
buf_nl = g_strconcat(buf, "\n", NULL);
if (regexp && command_line)
{
ret_comp = regcomp(®ex, regexp, 0);
if (!ret_comp)
{
ret_exec = regexec(®ex, buf_nl, 0, NULL, 0);
if (!ret_exec)
{
print_term(FALSE, buf_nl);
if (strcmp(domain, DOMAIN_INFO) == 0)
g_idle_add(log_normal_cb, buf_nl);
else
g_idle_add(log_msg_cb, buf_nl);
}
regfree(®ex);
}
}
else
{
print_term(FALSE, buf_nl);
if (strcmp(domain, DOMAIN_INFO) == 0)
g_idle_add(log_normal_cb, buf_nl);
else
g_idle_add(log_msg_cb, buf_nl);
}
g_free(buf);
}
int ei_s_print_term(char** s, const char* buf, int* index)
{
int r;
ei_x_buff x;
if (*s != NULL) {
x.buff = *s;
x.index = 0;
x.buffsz = BUFSIZ;
} else {
ei_x_new(&x);
}
r = print_term(NULL, &x, buf, index);
ei_x_append_buf(&x, "", 1); /* append '\0' */
*s = x.buff;
return r;
}
// not used anymore
static void print_benchmark(FILE *f, smt_benchmark_t *bench) {
uint32_t i, n;
n = bench->nformulas;
fprintf(f, "Benchmark %s\n", bench->name);
fprintf(f, "Logic: %s\n", bench->logic_name);
fprintf(f, "Parameter: %"PRId32"\n", bench->logic_parameter);
fprintf(f, "Status: %s\n", status2string[bench->status]);
fprintf(f, "Number of formulas or assumptions: %"PRIu32"\n", n);
for (i=0; i<n; i++) {
fprintf(f, "\n---- Assertion %"PRIu32" ----\n", i);
print_term(f, bench->formulas[i]);
fprintf(f, "\n");
}
}
int ei_print_term(FILE *fp, const char* buf, int* index)
{
return print_term(fp, NULL, buf, index);
}
static int print_term(FILE* fp, ei_x_buff* x,
const char* buf, int* index)
{
int i, doquote, n, m, ty, r;
char a[MAXATOMLEN], *p;
int ch_written = 0; /* counter of written chars */
erlang_pid pid;
erlang_port port;
erlang_ref ref;
double d;
long l;
int tindex = *index;
/* use temporary index for multiple (and failable) decodes */
if (fp == NULL && x == NULL) return -1;
doquote = 0;
ei_get_type_internal(buf, index, &ty, &n);
switch (ty) {
case ERL_ATOM_EXT:
case ERL_ATOM_UTF8_EXT:
case ERL_SMALL_ATOM_EXT:
case ERL_SMALL_ATOM_UTF8_EXT:
if (ei_decode_atom(buf, index, a) < 0)
goto err;
doquote = !islower((int)a[0]);
for (p = a; !doquote && *p != '\0'; ++p)
doquote = !(isalnum((int)*p) || *p == '_' || *p == '@');
if (doquote) {
xputc('\'', fp, x); ++ch_written;
}
xputs(a, fp, x); ch_written += strlen(a);
if (doquote) {
xputc('\'', fp, x); ++ch_written;
}
break;
case ERL_PID_EXT:
case ERL_NEW_PID_EXT:
if (ei_decode_pid(buf, index, &pid) < 0) goto err;
ch_written += xprintf(fp, x, "<%s.%d.%d>", pid.node,
pid.num, pid.serial);
break;
case ERL_PORT_EXT:
case ERL_NEW_PORT_EXT:
if (ei_decode_port(buf, index, &port) < 0) goto err;
ch_written += xprintf(fp, x, "#Port<%d.%d>", port.id, port.creation);
break;
case ERL_NEW_REFERENCE_EXT:
case ERL_NEWER_REFERENCE_EXT:
case ERL_REFERENCE_EXT:
if (ei_decode_ref(buf, index, &ref) < 0) goto err;
ch_written += xprintf(fp, x, "#Ref<");
for (i = 0; i < ref.len; ++i) {
ch_written += xprintf(fp, x, "%d", ref.n[i]);
if (i < ref.len - 1) {
xputc('.', fp, x); ++ch_written;
}
}
xputc('>', fp, x); ++ch_written;
break;
case ERL_NIL_EXT:
if (ei_decode_list_header(buf, index, &n) < 0) goto err;
ch_written += xprintf(fp, x, "[]");
break;
case ERL_LIST_EXT:
if (ei_decode_list_header(buf, &tindex, &n) < 0) goto err;
xputc('[', fp, x); ch_written++;
for (i = 0; i < n; ++i) {
r = print_term(fp, x, buf, &tindex);
if (r < 0) goto err;
ch_written += r;
if (i < n - 1) {
xputs(", ", fp, x); ch_written += 2;
}
}
if (ei_get_type_internal(buf, &tindex, &ty, &n) < 0) goto err;
if (ty != ERL_NIL_EXT) {
xputs(" | ", fp, x); ch_written += 3;
r = print_term(fp, x, buf, &tindex);
if (r < 0) goto err;
ch_written += r;
} else {
if (ei_decode_list_header(buf, &tindex, &n) < 0) goto err;
}
xputc(']', fp, x); ch_written++;
*index = tindex;
break;
case ERL_STRING_EXT:
p = ei_malloc(n+1);
if (p == NULL) goto err;
if (ei_decode_string(buf, index, p) < 0) {
ei_free(p);
goto err;
}
ch_written += print_string(fp, x, p, n);
ei_free(p);
break;
case ERL_SMALL_TUPLE_EXT:
case ERL_LARGE_TUPLE_EXT:
if (ei_decode_tuple_header(buf, &tindex, &n) < 0) goto err;
xputc('{', fp, x); ch_written++;
for (i = 0; i < n; ++i) {
r = print_term(fp, x, buf, &tindex);
if (r < 0) goto err;
ch_written += r;
if (i < n-1) {
xputs(", ", fp, x); ch_written += 2;
}
}
*index = tindex;
xputc('}', fp, x); ch_written++;
break;
case ERL_BINARY_EXT:
p = ei_malloc(n);
if (p == NULL) goto err;
if (ei_decode_binary(buf, index, p, &l) < 0) {
ei_free(p);
goto err;
}
ch_written += xprintf(fp, x, "#Bin<");
if (l > BINPRINTSIZE)
m = BINPRINTSIZE;
else
m = l;
--m;
for (i = 0; i < m; ++i) {
ch_written += xprintf(fp, x, "%d,", p[i]);
}
ch_written += xprintf(fp, x, "%d", p[i]);
if (l > BINPRINTSIZE)
ch_written += xprintf(fp, x, ",...");
xputc('>', fp, x); ++ch_written;
ei_free(p);
break;
case ERL_SMALL_INTEGER_EXT:
case ERL_INTEGER_EXT:
if (ei_decode_long(buf, index, &l) < 0) goto err;
ch_written += xprintf(fp, x, "%ld", l);
break;
case ERL_SMALL_BIG_EXT:
case ERL_LARGE_BIG_EXT:
{
erlang_big *b;
char *ds;
if ( (b = ei_alloc_big(n)) == NULL) goto err;
if (ei_decode_big(buf, index, b) < 0) {
ei_free_big(b);
goto err;
}
if ( (ds = ei_big_to_str(b)) == NULL ) {
ei_free_big(b);
goto err;
}
ch_written += xprintf(fp, x, ds);
free(ds);
ei_free_big(b);
}
break;
case ERL_FLOAT_EXT:
case NEW_FLOAT_EXT:
if (ei_decode_double(buf, index, &d) < 0) goto err;
ch_written += xprintf(fp, x, "%f", d);
break;
default:
goto err;
}
return ch_written;
err:
return -1;
}
void dump(Term* term)
{
Value str;
print_term(term, &str);
std::cout << as_cstring(&str);
}
static void eval_mem_rules(double interval)
{
long cmmpages_size, cmm_inc, cmm_dec, cmm_new;
double free_memory, swaprate, apcr;
char *procinfo_current, *procinfo_prev;
procinfo_current = meminfo + history_current * meminfo_size;
free_memory = get_proc_value(procinfo_current, "MemFree", ':');
procinfo_current = vmstat + history_current * vmstat_size;
procinfo_prev = vmstat + history_prev * vmstat_size;
swaprate = (get_proc_value(procinfo_current, "pswpin", ' ') +
get_proc_value(procinfo_current, "pswpout", ' ') -
get_proc_value(procinfo_prev, "pswpin", ' ') -
get_proc_value(procinfo_prev, "pswpout", ' ')) /
interval;
apcr = (get_proc_value(procinfo_current, "pgpgin", ' ') +
get_proc_value(procinfo_current, "pgpgout", ' ') -
get_proc_value(procinfo_prev, "pgpgin", ' ') -
get_proc_value(procinfo_prev, "pgpgout", ' ')) /
interval;
cmmpages_size = get_cmmpages_size();
symbols.apcr = apcr; // apcr in 512 byte blocks / sec
symbols.swaprate = swaprate; // swaprate in 4K pages / sec
symbols.freemem = free_memory / 1024; // freemem in MB
cmm_inc = eval_double(cfg.cmm_inc, &symbols);
/* cmm_dec is optional */
if (cfg.cmm_dec)
cmm_dec = eval_double(cfg.cmm_dec, &symbols);
else
cmm_dec = cmm_inc;
/* only use this for development and testing */
if (debug && foreground == 1) {
printf("------------------- Memory ------------------\n");
printf("cmm_min: %ld\n", cfg.cmm_min);
printf("cmm_max: %ld\n", cfg.cmm_max);
printf("swaprate: %f\n", symbols.swaprate);
printf("apcr: %f\n", symbols.apcr);
printf("cmm_inc: %ld = ", cmm_inc);
print_term(cfg.cmm_inc);
printf("\n");
printf("cmm_dec: %ld = ", cmm_dec);
if (cfg.cmm_dec)
print_term(cfg.cmm_dec);
else
print_term(cfg.cmm_inc);
printf("\n");
printf("free memory: %f MB\n", symbols.freemem);
printf("---------------------------------------------\n");
printf("cmm_pages: %ld\n", cmmpages_size);
printf("---------------------------------------------\n");
printf("memplug: ");
print_term(cfg.memplug);
printf("\n");
printf("memunplug: ");
print_term(cfg.memunplug);
printf("\n");
printf("---------------------------------------------\n");
}
cmm_new = cmmpages_size;
/* Evaluate the memplug rule */
if (eval_term(cfg.memplug, &symbols)) {
if (cmm_dec < 0) {
cpuplugd_error("cmm_dec went negative (%ld), set it "
"to 0.\n", cmm_dec);
cmm_dec = 0;
}
cmm_new -= cmm_dec;
/* Evaluate the memunplug rule only if memplug did not match */
} else if (eval_term(cfg.memunplug, &symbols)) {
if (cmm_inc < 0) {
cpuplugd_error("cmm_inc went negative (%ld), set it "
"to 0.\n", cmm_inc);
cmm_inc = 0;
}
cmm_new += cmm_inc;
}
if (cmm_new < cfg.cmm_min) {
cpuplugd_debug("minimum memory limit is reached\n");
cmm_new = cfg.cmm_min;
}
if (cmm_new > cfg.cmm_max) {
cpuplugd_debug("maximum memory limit is reached\n");
cmm_new = cfg.cmm_max;
}
if (cmm_new != cmmpages_size)
set_cmm_pages(cmm_new);
}
static void eval_cpu_rules(void)
{
double diffs[CPUSTATS], diffs_total, percent_factor;
char *procinfo_current, *procinfo_prev;
int cpu, nr_cpus, on_off;
nr_cpus = get_numcpus();
procinfo_current = cpustat + history_current * cpustat_size;
procinfo_prev = cpustat + history_prev * cpustat_size;
diffs[0] = get_proc_value(procinfo_current, "user", ' ') -
get_proc_value(procinfo_prev, "user", ' ');
diffs[1] = get_proc_value(procinfo_current, "nice", ' ') -
get_proc_value(procinfo_prev, "nice", ' ');
diffs[2] = get_proc_value(procinfo_current, "system", ' ') -
get_proc_value(procinfo_prev, "system", ' ');
diffs[3] = get_proc_value(procinfo_current, "idle", ' ') -
get_proc_value(procinfo_prev, "idle", ' ');
diffs[4] = get_proc_value(procinfo_current, "iowait", ' ') -
get_proc_value(procinfo_prev, "iowait", ' ');
diffs[5] = get_proc_value(procinfo_current, "irq", ' ') -
get_proc_value(procinfo_prev, "irq", ' ');
diffs[6] = get_proc_value(procinfo_current, "softirq", ' ') -
get_proc_value(procinfo_prev, "softirq", ' ');
diffs[7] = get_proc_value(procinfo_current, "steal", ' ') -
get_proc_value(procinfo_prev, "steal", ' ');
diffs[8] = get_proc_value(procinfo_current, "guest", ' ') -
get_proc_value(procinfo_prev, "guest", ' ');
diffs[9] = get_proc_value(procinfo_current, "guest_nice", ' ') -
get_proc_value(procinfo_prev, "guest_nice", ' ');
diffs_total = get_proc_value(procinfo_current, "total_ticks", ' ') -
get_proc_value(procinfo_prev, "total_ticks", ' ');
if (diffs_total == 0)
diffs_total = 1;
symbols.loadavg = get_proc_value(procinfo_current, "loadavg", ' ');
symbols.runnable_proc = get_proc_value(procinfo_current,
"runnable_proc", ' ');
symbols.onumcpus = get_proc_value(procinfo_current, "onumcpus", ' ');
percent_factor = 100 * symbols.onumcpus;
symbols.user = (diffs[0] / diffs_total) * percent_factor;
symbols.nice = (diffs[1] / diffs_total) * percent_factor;
symbols.system = (diffs[2] / diffs_total) * percent_factor;
symbols.idle = (diffs[3] / diffs_total) * percent_factor;
symbols.iowait = (diffs[4] / diffs_total) * percent_factor;
symbols.irq = (diffs[5] / diffs_total) * percent_factor;
symbols.softirq = (diffs[6] / diffs_total) * percent_factor;
symbols.steal = (diffs[7] / diffs_total) * percent_factor;
symbols.guest = (diffs[8] / diffs_total) * percent_factor;
symbols.guest_nice = (diffs[9] / diffs_total) * percent_factor;
/* only use this for development and testing */
cpuplugd_debug("cpustat values:\n%s", cpustat + history_current *
cpustat_size);
if (debug && foreground == 1) {
printf("-------------------- CPU --------------------\n");
printf("cpu_min: %ld\n", cfg.cpu_min);
printf("cpu_max: %ld\n", cfg.cpu_max);
printf("loadavg: %f \n", symbols.loadavg);
printf("user percent = %f\n", symbols.user);
printf("nice percent = %f\n", symbols.nice);
printf("system percent = %f\n", symbols.system);
printf("idle percent = %f\n", symbols.idle);
printf("iowait percent = %f\n", symbols.iowait);
printf("irq percent = %f\n", symbols.irq);
printf("softirq percent = %f\n", symbols.softirq);
printf("steal percent = %f\n", symbols.steal);
printf("guest percent = %f\n", symbols.guest);
printf("guest_nice percent = %f\n", symbols.guest_nice);
printf("numcpus %d\n", nr_cpus);
printf("runnable_proc: %d\n", (int) symbols.runnable_proc);
printf("---------------------------------------------\n");
printf("onumcpus: %d\n", (int) symbols.onumcpus);
printf("---------------------------------------------\n");
printf("hotplug: ");
print_term(cfg.hotplug);
printf("\n");
printf("hotunplug: ");
print_term(cfg.hotunplug);
printf("\n");
printf("---------------------------------------------\n");
}
on_off = 0;
/* Evaluate the hotplug rule */
if (eval_term(cfg.hotplug, &symbols))
on_off++;
/* Evaluate the hotunplug rule only if hotplug did not match */
else if (eval_term(cfg.hotunplug, &symbols))
on_off--;
if (on_off > 0) {
/* check the cpu nr limit */
if (symbols.onumcpus + 1 > cfg.cpu_max) {
/* cpu limit reached */
cpuplugd_debug("maximum cpu limit is reached\n");
return;
}
/* try to find a offline cpu */
for (cpu = 0; cpu < nr_cpus; cpu++)
if (is_online(cpu) == 0 && cpu_is_configured(cpu) != 0)
break;
if (cpu < nr_cpus) {
cpuplugd_debug("cpu with id %d is currently offline "
"and will be enabled\n", cpu);
if (hotplug(cpu) == -1)
cpuplugd_debug("unable to find a cpu which "
"can be enabled\n");
} else {
/*
* In case we tried to enable a cpu but this failed.
* This is the case if a cpu is deconfigured
*/
cpuplugd_debug("unable to find a cpu which can "
"be enabled\n");
}
} else if (on_off < 0) {
/* check cpu nr limit */
if (symbols.onumcpus <= cfg.cpu_min) {
cpuplugd_debug("minimum cpu limit is reached\n");
return;
}
/* try to find a online cpu */
for (cpu = get_numcpus() - 1; cpu >= 0; cpu--) {
if (is_online(cpu) != 0)
break;
}
if (cpu > 0) {
cpuplugd_debug("cpu with id %d is currently online "
"and will be disabled\n", cpu);
hotunplug(cpu);
}
}
}
int main() {
int choice, len;
int *p;
char buf[2];
char first_array[] = "first";
char second_array[] = "second";
/*
print_term("Rogue test\n\n");
print_term("0 - End test\n");
print_term("1 - NULL pointer dereference\n");
print_term("2 - Access memory in Kseg0\n");
print_term("3 - Operate a semaphore not in Useg3\n");
print_term("4 - Request to delay for < 0 seconds\n");
print_term("5 - Write to .text section\n");
print_term("6 - Buffer overflow!\n");
*/
do {
print_term("\nEnter your choice: ");
len = read_term(buf);
if (len > 2) len = 2;
buf[1] = '\0';
choice = to_num(buf);
} while((choice < 0) || (choice > 6));
switch (choice) {
case 0:
print_term("Terminating gracefully...\n");
return 0;
break;
case 1:
p = NULL;
*p = 10; /* Should kill the process */
print_term("Should not get here!\n");
break;
case 2:
p = (int *)(SEG1 + 4);
*p = 10;
print_term("Should not get here!\n");
break;
case 3:
p = (int *)(SEG2 + (20 * PAGE_SIZE));
*p = 0; /* Should succeed */
print_term("Set the semaphore to 0...\n");
V(p, 1); /* Should fail */
print_term("Should not get here!\n");
break;
case 4:
delay(-6);
print_term("Should not get here!\n");
break;
case 5:
p = (int *)(SEG2 + 10); /* This is in the .text section */
*p = 42;
print_term("Should not get here!\n");
break;
case 6:
print_term("\nfirst_array[] is ");
print_term(first_array);
print_term("\nsecond_array[] is ");
print_term(second_array);
print_term("\nnow enter a string longer than 6 characters...");
read_term(first_array);
print_term("\nnow first_array[] is ");
print_term(first_array);
print_term("\nand second_array[] is ");
print_term(second_array);
return 0;
default:
print_term("Should not get here...\n");
break;
}
print_term("Houston, we have a problem...\n");
return 0;
}
void DisassemblerContext::print_term_definition(const ValuePtr<>& term, bool global) {
*m_output << name(term) << " = ";
switch (term->term_type()) {
case term_functional: {
if (global)
*m_output << "define ";
print_functional_term(value_cast<FunctionalValue>(term), false);
*m_output << ";\n";
break;
}
case term_function_type: {
if (global)
*m_output << "define ";
print_function_type_term(value_cast<FunctionType>(term), false);
*m_output << ";\n";
break;
}
case term_instruction: {
print_instruction_term(value_cast<Instruction>(term));
break;
}
case term_phi: {
print_phi_term(value_cast<Phi>(term));
break;
}
case term_global_variable: {
ValuePtr<GlobalVariable> gvar = value_cast<GlobalVariable>(term);
*m_output << "global ";
if (gvar->constant())
*m_output << "const ";
print_term(gvar->value_type(), true);
if (gvar->value()) {
*m_output << ' ';
print_term(gvar->value(), true);
}
*m_output << ";\n";
return;
}
case term_function: {
print_function(value_cast<Function>(term));
return;
}
case term_function_parameter: {
ValuePtr<FunctionParameter> parameter = value_cast<FunctionParameter>(term);
ValuePtr<Function> function = parameter->function();
unsigned n = 0;
for (Function::ParameterList::const_iterator ii = function->parameters().begin(), ie = function->parameters().end(); ii != ie; ++ii, ++n) {
if (parameter == *ii) {
*m_output << "[function parameter " << n << "]\n";
return;
}
}
*m_output << "[invalid function parameter]\n";
return;
}
case term_apply: {
if (global)
*m_output << "define ";
print_apply_term(value_cast<ApplyType>(term), false);
*m_output << ";\n";
return;
}
case term_exists: {
if (global)
*m_output << "define ";
print_exists(value_cast<Exists>(term), false);
*m_output << ";\n";
return;
}
case term_recursive: {
print_recursive(value_cast<RecursiveType>(term));
return;
}
case term_recursive_parameter: *m_output << "[recursive parameter]\n"; return;
case term_parameter_placeholder: *m_output << "[parameter placeholder]\n"; return;
case term_upref_null: *m_output << "upref_null\n"; return;
default:
PSI_FAIL("unexpected term type - cannot print a definition");
}
}
int print_term_and_free(FILE* stream, term* t) {
int ans = print_term(stream, t);
free_term(t);
return ans;
}
void print_register(int i)
{
printf("X%d = ", i);
print_term(X[i].s1.addr);
printf("\n");
}
void dump(Term* term)
{
print_term(term, std::cout);
}
void DisassemblerContext::print_functional_term(const ValuePtr<FunctionalValue>& term, bool bracket) {
if (ValuePtr<BooleanValue> bool_value = dyn_cast<BooleanValue>(term)) {
*m_output << (bool_value->value() ? "true" : "false");
} else if (ValuePtr<IntegerType> int_type = dyn_cast<IntegerType>(term)) {
if (!int_type->is_signed())
*m_output << 'u';
*m_output << 'i';
const char *width;
switch (int_type->width()) {
case IntegerType::i8: width = "8"; break;
case IntegerType::i16: width = "16"; break;
case IntegerType::i32: width = "32"; break;
case IntegerType::i64: width = "64"; break;
case IntegerType::i128: width = "128"; break;
case IntegerType::iptr: width = "ptr"; break;
default: PSI_FAIL("unknown integer width");
}
*m_output << width;
} else if (ValuePtr<IntegerValue> int_value = dyn_cast<IntegerValue>(term)) {
ValuePtr<IntegerType> type = int_value->type();
*m_output << '#';
if (!type->is_signed())
*m_output << 'u';
char width;
switch (type->width()) {
case IntegerType::i8: width = 'b'; break;
case IntegerType::i16: width = 's'; break;
case IntegerType::i32: width = 'i'; break;
case IntegerType::i64: width = 'l'; break;
case IntegerType::i128: width = 'q'; break;
case IntegerType::iptr: width = 'p'; break;
default: PSI_FAIL("unknown integer width");
}
*m_output << width;
int_value->value().print(error_context().bind(term->location()), *m_output, type->is_signed());
} else if (ValuePtr<FloatType> float_type = dyn_cast<FloatType>(term)) {
const char *width;
switch (float_type->width()) {
case FloatType::fp32: width = "fp32"; break;
case FloatType::fp64: width = "fp64"; break;
case FloatType::fp128: width = "fp128"; break;
case FloatType::fp_x86_80: width = "fp-x86-80"; break;
case FloatType::fp_ppc_128: width = "fp-ppc-128"; break;
default: PSI_FAIL("unknown integer width");
}
*m_output << width;
} else if (ValuePtr<ResolvedParameter> resolved_param = dyn_cast<ResolvedParameter>(term)) {
ParameterNameList::reverse_iterator it = m_parameter_names.rbegin();
if (resolved_param->depth() < m_parameter_names.size()) {
std::advance(it, resolved_param->depth());
PSI_ASSERT(resolved_param->index() < it->size());
*m_output << (*it)[resolved_param->index()];
} else {
*m_output << "[unknown parameter : ";
print_term(resolved_param->type(), false);
*m_output << "]";
}
} else if (ValuePtr<UnwrapParameter> unwrap_param = dyn_cast<UnwrapParameter>(term)) {
*m_output << "unwrap_param ";
print_term(unwrap_param->value(), true);
*m_output << " " << unwrap_param->index();
} else {
class MyVisitor : public FunctionalValueVisitor {
DisassemblerContext *m_self;
const char *m_operation;
bool m_bracket;
bool m_first;
public:
MyVisitor(DisassemblerContext *self, const char *operation, bool bracket)
: m_self(self), m_operation(operation), m_bracket(bracket), m_first(true) {}
virtual void next(const ValuePtr<>& ptr) {
if (m_first) {
if (m_bracket)
*m_self->m_output << '(';
*m_self->m_output << m_operation;
m_first = false;
}
*m_self->m_output << ' ';
m_self->print_term(ptr, true);
}
bool empty() const {return m_first;}
};
MyVisitor my_visitor(this, term->operation_name(), bracket);
term->functional_visit(my_visitor);
if (my_visitor.empty()) {
*m_output << term->operation_name();
} else if (bracket) {
*m_output << ')';
}
}
}
