void print_opnd_type(Opnd o) {
if(is_reg(o)) {
if(is_hard_reg(o)) {
std::cout << "(is hard reg)";
}
else if(is_virtual_reg(o)) {
std::cout << "(is virtual reg)[$vr"<<get_reg(o)<<"]";
}
else {
std::cout << "(is undeterminate reg)";
}
}
else if(is_immed(o)) {
if(is_immed_integer(o)) {
std::cout << "(is immed integer)";
}
else if(is_immed_string(o)) {
std::cout << "(is immed string)";
}
else {
std::cout << "(is undeterminate immed)";
}
}
else if(is_addr(o)) {
if(is_addr_sym(o)) {
FormattedText ft;
Sym *symbol = get_sym(o);
symbol->print(ft);
char* addr_name;
addr_name = (char*)(symbol->get_name()).c_str();
std::cout << "(is addr sym)["<<addr_name<<"]";
}
else if(is_addr_exp(o)) {
std::cout << "(is addr exp)";
}
else {
std::cout << "(is undeterminate addr)";
}
}
else if(is_var(o)) {
FormattedText ft;
VarSym *vsym = get_var(o);
vsym->print(ft);
char* var_name;
var_name = (char*)(vsym->get_name()).c_str();
std::cout << "(is var)["<<var_name<<"]";
}
else if(is_null(o)) {
std::cout << "(is null)";
}
else {
std::cout << "(I don't know) !!!)";
}
return;
}
int
is_host (const char *address)
{
if (is_addr (address) || is_hostname (address))
return (TRUE);
return (FALSE);
}
VOID update_stack_heap_region(CONTEXT* ctxt, ADDRINT addr) {
trace_enter();
if (!is_addr(addr)) {
stack_heap_region.extend(addr);
}
trace_leave();
}
static bool uses_current_addr(struct ir3_sched_ctx *ctx,
struct ir3_instruction *instr)
{
unsigned i;
for (i = 1; i < instr->regs_count; i++) {
struct ir3_register *reg = instr->regs[i];
if (reg->flags & IR3_REG_SSA) {
if (is_addr(reg->instr)) {
struct ir3_instruction *addr;
addr = reg->instr->regs[1]->instr; /* the mova */
if (ctx->addr == addr)
return true;
}
}
}
return false;
}
/*
* This function assigns a server address to a session, and sets SN_ADDR_SET.
* The address is taken from the currently assigned server, or from the
* dispatch or transparent address.
*
* It may return :
* SRV_STATUS_OK if everything is OK.
* SRV_STATUS_INTERNAL for other unrecoverable errors.
*
* Upon successful return, the session flag SN_ADDR_SET is set. This flag is
* not cleared, so it's to the caller to clear it if required.
*
* The caller is responsible for having already assigned a connection
* to si->end.
*
*/
int assign_server_address(struct session *s)
{
struct connection *cli_conn = objt_conn(s->si[0].end);
struct connection *srv_conn = objt_conn(s->si[1].end);
#ifdef DEBUG_FULL
fprintf(stderr,"assign_server_address : s=%p\n",s);
#endif
if ((s->flags & SN_DIRECT) || (s->be->lbprm.algo & BE_LB_KIND)) {
/* A server is necessarily known for this session */
if (!(s->flags & SN_ASSIGNED))
return SRV_STATUS_INTERNAL;
srv_conn->addr.to = objt_server(s->target)->addr;
if (!is_addr(&srv_conn->addr.to) && cli_conn) {
/* if the server has no address, we use the same address
* the client asked, which is handy for remapping ports
* locally on multiple addresses at once. Nothing is done
* for AF_UNIX addresses.
*/
conn_get_to_addr(cli_conn);
if (cli_conn->addr.to.ss_family == AF_INET) {
((struct sockaddr_in *)&srv_conn->addr.to)->sin_addr = ((struct sockaddr_in *)&cli_conn->addr.to)->sin_addr;
} else if (cli_conn->addr.to.ss_family == AF_INET6) {
((struct sockaddr_in6 *)&srv_conn->addr.to)->sin6_addr = ((struct sockaddr_in6 *)&cli_conn->addr.to)->sin6_addr;
}
}
/* if this server remaps proxied ports, we'll use
* the port the client connected to with an offset. */
if ((objt_server(s->target)->flags & SRV_F_MAPPORTS) && cli_conn) {
int base_port;
conn_get_to_addr(cli_conn);
/* First, retrieve the port from the incoming connection */
base_port = get_host_port(&cli_conn->addr.to);
/* Second, assign the outgoing connection's port */
base_port += get_host_port(&srv_conn->addr.to);
set_host_port(&srv_conn->addr.to, base_port);
}
}
else if (s->be->options & PR_O_DISPATCH) {
/* connect to the defined dispatch addr */
srv_conn->addr.to = s->be->dispatch_addr;
}
else if ((s->be->options & PR_O_TRANSP) && cli_conn) {
/* in transparent mode, use the original dest addr if no dispatch specified */
conn_get_to_addr(cli_conn);
if (cli_conn->addr.to.ss_family == AF_INET || cli_conn->addr.to.ss_family == AF_INET6)
srv_conn->addr.to = cli_conn->addr.to;
}
else if (s->be->options & PR_O_HTTP_PROXY) {
/* If HTTP PROXY option is set, then server is already assigned
* during incoming client request parsing. */
}
else {
/* no server and no LB algorithm ! */
return SRV_STATUS_INTERNAL;
}
/* Copy network namespace from client connection */
srv_conn->proxy_netns = cli_conn ? cli_conn->proxy_netns : NULL;
s->flags |= SN_ADDR_SET;
return SRV_STATUS_OK;
}
int assign_server(struct session *s)
{
struct connection *conn;
struct server *conn_slot;
struct server *srv, *prev_srv;
int err;
DPRINTF(stderr,"assign_server : s=%p\n",s);
err = SRV_STATUS_INTERNAL;
if (unlikely(s->pend_pos || s->flags & SN_ASSIGNED))
goto out_err;
prev_srv = objt_server(s->target);
conn_slot = s->srv_conn;
/* We have to release any connection slot before applying any LB algo,
* otherwise we may erroneously end up with no available slot.
*/
if (conn_slot)
sess_change_server(s, NULL);
/* We will now try to find the good server and store it into <objt_server(s->target)>.
* Note that <objt_server(s->target)> may be NULL in case of dispatch or proxy mode,
* as well as if no server is available (check error code).
*/
srv = NULL;
s->target = NULL;
conn = objt_conn(s->si[1].end);
if (conn &&
(conn->flags & CO_FL_CONNECTED) &&
objt_server(conn->target) && __objt_server(conn->target)->proxy == s->be &&
((s->txn.flags & TX_PREFER_LAST) ||
((s->be->options & PR_O_PREF_LAST) &&
(!s->be->max_ka_queue ||
server_has_room(__objt_server(conn->target)) ||
(__objt_server(conn->target)->nbpend + 1) < s->be->max_ka_queue))) &&
srv_is_usable(__objt_server(conn->target))) {
/* This session was relying on a server in a previous request
* and the proxy has "option prefer-last-server" set, so
* let's try to reuse the same server.
*/
srv = __objt_server(conn->target);
s->target = &srv->obj_type;
}
else if (s->be->lbprm.algo & BE_LB_KIND) {
/* we must check if we have at least one server available */
if (!s->be->lbprm.tot_weight) {
err = SRV_STATUS_NOSRV;
goto out;
}
/* First check whether we need to fetch some data or simply call
* the LB lookup function. Only the hashing functions will need
* some input data in fact, and will support multiple algorithms.
*/
switch (s->be->lbprm.algo & BE_LB_LKUP) {
case BE_LB_LKUP_RRTREE:
srv = fwrr_get_next_server(s->be, prev_srv);
break;
case BE_LB_LKUP_FSTREE:
srv = fas_get_next_server(s->be, prev_srv);
break;
case BE_LB_LKUP_LCTREE:
srv = fwlc_get_next_server(s->be, prev_srv);
break;
case BE_LB_LKUP_CHTREE:
case BE_LB_LKUP_MAP:
if ((s->be->lbprm.algo & BE_LB_KIND) == BE_LB_KIND_RR) {
if (s->be->lbprm.algo & BE_LB_LKUP_CHTREE)
srv = chash_get_next_server(s->be, prev_srv);
else
srv = map_get_server_rr(s->be, prev_srv);
break;
}
else if ((s->be->lbprm.algo & BE_LB_KIND) != BE_LB_KIND_HI) {
/* unknown balancing algorithm */
err = SRV_STATUS_INTERNAL;
goto out;
}
switch (s->be->lbprm.algo & BE_LB_PARM) {
case BE_LB_HASH_SRC:
conn = objt_conn(s->si[0].end);
if (conn && conn->addr.from.ss_family == AF_INET) {
srv = get_server_sh(s->be,
(void *)&((struct sockaddr_in *)&conn->addr.from)->sin_addr,
4);
}
else if (conn && conn->addr.from.ss_family == AF_INET6) {
srv = get_server_sh(s->be,
(void *)&((struct sockaddr_in6 *)&conn->addr.from)->sin6_addr,
16);
}
else {
/* unknown IP family */
err = SRV_STATUS_INTERNAL;
goto out;
}
break;
case BE_LB_HASH_URI:
/* URI hashing */
if (s->txn.req.msg_state < HTTP_MSG_BODY)
break;
srv = get_server_uh(s->be,
b_ptr(s->req.buf, -http_uri_rewind(&s->txn.req)),
s->txn.req.sl.rq.u_l);
break;
case BE_LB_HASH_PRM:
/* URL Parameter hashing */
if (s->txn.req.msg_state < HTTP_MSG_BODY)
break;
srv = get_server_ph(s->be,
b_ptr(s->req.buf, -http_uri_rewind(&s->txn.req)),
s->txn.req.sl.rq.u_l);
if (!srv && s->txn.meth == HTTP_METH_POST)
srv = get_server_ph_post(s);
break;
case BE_LB_HASH_HDR:
/* Header Parameter hashing */
if (s->txn.req.msg_state < HTTP_MSG_BODY)
break;
srv = get_server_hh(s);
break;
case BE_LB_HASH_RDP:
/* RDP Cookie hashing */
srv = get_server_rch(s);
break;
default:
/* unknown balancing algorithm */
err = SRV_STATUS_INTERNAL;
goto out;
}
/* If the hashing parameter was not found, let's fall
* back to round robin on the map.
*/
if (!srv) {
if (s->be->lbprm.algo & BE_LB_LKUP_CHTREE)
srv = chash_get_next_server(s->be, prev_srv);
else
srv = map_get_server_rr(s->be, prev_srv);
}
/* end of map-based LB */
break;
default:
/* unknown balancing algorithm */
err = SRV_STATUS_INTERNAL;
goto out;
}
if (!srv) {
err = SRV_STATUS_FULL;
goto out;
}
else if (srv != prev_srv) {
s->be->be_counters.cum_lbconn++;
srv->counters.cum_lbconn++;
}
s->target = &srv->obj_type;
}
else if (s->be->options & (PR_O_DISPATCH | PR_O_TRANSP)) {
s->target = &s->be->obj_type;
}
else if ((s->be->options & PR_O_HTTP_PROXY) &&
(conn = objt_conn(s->si[1].end)) &&
is_addr(&conn->addr.to)) {
/* in proxy mode, we need a valid destination address */
s->target = &s->be->obj_type;
}
else {
err = SRV_STATUS_NOSRV;
goto out;
}
s->flags |= SN_ASSIGNED;
err = SRV_STATUS_OK;
out:
/* Either we take back our connection slot, or we offer it to someone
* else if we don't need it anymore.
*/
if (conn_slot) {
if (conn_slot == srv) {
sess_change_server(s, srv);
} else {
if (may_dequeue_tasks(conn_slot, s->be))
process_srv_queue(conn_slot);
}
}
out_err:
return err;
}
void
host_or_die(const char *str)
{
if(!str || (!is_addr(str) && !is_hostname(str)))
usage_va(_("Invalid hostname/address - %s"), str);
}
VOID Fini(INT32 code, VOID *v) {
trace_enter();
#define append_type(type) \
if (need_comma) \
ofile << "," ; \
ofile << (type); \
need_comma = true
for(unsigned int fid = 1; fid <= fn_nb(); fid++) {
if (nb_call[fid] < NB_CALLS_TO_CONCLUDE)
continue;
ofile << fn_img(fid) << ":" << fn_imgaddr(fid)
<< ":" << fn_name(fid)
<< ":";
bool need_comma = false;
unsigned int param_val_size = 1 + nb_param_int[fid] + nb_param_int_stack[fid];
for (unsigned int pid = 0; pid < param_val_size; pid++) {
if (((float) nb_out[fid][pid]) > 0.75 * ((float) nb_call[fid])) {
debug("Found 'out parameter' candidate : [%s@%lX] %s %u (%u <=> %u)\n",
fn_img(fid).c_str(),
fn_imgaddr(fid),
fn_name(fid).c_str(),
pid,
nb_out[fid][pid],
nb_call[fid]);
}
if (pid == 0 && has_return[fid] == 0) {
append_type("VOID");
}
else if (pid == 0 && has_return[fid] == 2) {
append_type("FLOAT");
}
else if (pid < 1 + nb_param_int[fid] && param_is_not_addr[fid][pid]) {
append_type("INT");
}
else if (param_val[fid][pid]->size() == 0) {
append_type("UNDEF");
}
else {
int param_addr = 0;
for (list<UINT64>::iterator it = param_val[fid][pid]->begin(); it != param_val[fid][pid]->end(); it++) {
if (is_addr(*it)) {
param_addr++;
}
}
float coef = ((float) param_addr) / ((float) param_val[fid][pid]->size());
append_type(coef > THRESHOLD ? "ADDR" : "INT");
ofile << "(" << coef << ")";
}
}
for (unsigned int pid = 0;
pid < nb_param_float[fid] + nb_param_float_stack[fid];
pid++) {
append_type("FLOAT");
}
ofile << endl;
}
ofile.close();
trace_leave();
}