// Execution stage (vector).
cen64_flatten static inline void rsp_v_ex_stage(struct rsp *rsp) {
struct rsp_rdex_latch *rdex_latch = &rsp->pipeline.rdex_latch;
rsp_vect_t vd_reg, vs_reg, vt_shuf_reg, zero;
unsigned vs, vt, vd, e;
uint32_t iw;
if (!(rdex_latch->opcode.flags & OPCODE_INFO_VECTOR))
return;
iw = rdex_latch->iw;
vs = GET_VS(iw);
vt = GET_VT(iw);
vd = GET_VD(iw);
e = GET_E (iw);
vs_reg = rsp_vect_load_unshuffled_operand(rsp->cp2.regs[vs].e);
vt_shuf_reg = rsp_vect_load_and_shuffle_operand(rsp->cp2.regs[vt].e, e);
zero = rsp_vzero();
// Finally, execute the instruction.
#ifdef PRINT_EXEC
debug("%.8X: %s\n", rdex_latch->common.pc,
rsp_vector_opcode_mnemonics[rdex_latch->opcode.id]);
#endif
vd_reg = rsp_vector_function_table[rdex_latch->opcode.id](
rsp, iw, vt_shuf_reg, vs_reg, zero);
rsp_vect_write_operand(rsp->cp2.regs[vd].e, vd_reg);
}
void log_SNM_hdr( const snm_hdr_t *hdr )
{
traceEvent( TRACE_DEBUG, "HEADER type=%d S=%d C=%d N=%d A=%d E=%d Seq=%d", hdr->type,
GET_S(hdr->flags), GET_C(hdr->flags), GET_N(hdr->flags), GET_A(hdr->flags), GET_E(hdr->flags),
hdr->seq_num );
}
static int process_sn_msg( n2n_sn_t *sss,
const struct sockaddr_in *sender_sock,
const uint8_t *msg_buf,
size_t msg_size,
time_t now)
{
snm_hdr_t hdr; /* common fields in the packet header */
size_t rem;
size_t idx;
size_t msg_type;
n2n_sock_t sender_sn;
traceEvent( TRACE_DEBUG, "process_sn_msg(%lu)", msg_size );
sn_cpy(&sender_sn, (const n2n_sock_t *) sender_sock);
sender_sn.port = htons(sender_sn.port);
rem = msg_size; /* Counts down bytes of packet to protect against buffer overruns. */
idx = 0; /* marches through packet header as parts are decoded. */
if (decode_SNM_hdr(&hdr, msg_buf, &rem, &idx) < 0)
{
traceEvent(TRACE_ERROR, "Failed to decode header");
return -1; /* failed to decode packet */
}
log_SNM_hdr(&hdr);
msg_type = hdr.type; /* message type */
if (msg_type == SNM_TYPE_REQ_LIST_MSG)
{
n2n_SNM_REQ_t req;
if (sss->snm_discovery_state != N2N_SNM_STATE_READY)
{
traceEvent(TRACE_ERROR, "Received SNM REQ but supernode is NOT READY");
return -1;
}
decode_SNM_REQ(&req, &hdr, msg_buf, &rem, &idx);
log_SNM_REQ(&req);
if (GET_A(hdr.flags))
{
/* request for ADV */
if (GET_E(hdr.flags))
{
/* request from edge wanting to register a new community */
struct comm_info *ci = NULL;
int need_write = 0;
if (req.comm_num != 1)
{
traceEvent(TRACE_ERROR, "Received SNM REQ from edge with comm_num=%d", req.comm_num);
return -1;
}
need_write = add_new_community(&sss->communities, req.comm_ptr[0].name, &ci);
if (need_write)
{
write_comm_list_to_file(sss->communities.filename,
sss->communities.list_head);
advertise_community_to_all(sss, ci->community_name);
}
}
send_snm_adv(sss, &sender_sn, NULL);
}
else
{
/* request for INFO */
send_snm_rsp(sss, &sender_sn, &hdr, &req);
}
if (!GET_E(hdr.flags))
{
update_and_save_supernodes(&sss->supernodes, &sender_sn, 1);
}
}
else if (msg_type == SNM_TYPE_RSP_LIST_MSG)
{
n2n_SNM_INFO_t rsp;
int sn_num = 0;
struct sn_info *new_sn = NULL;
if (sss->snm_discovery_state == N2N_SNM_STATE_READY)
{
traceEvent(TRACE_ERROR, "Received SNM RSP but supernode is READY");
return -1;
}
decode_SNM_INFO(&rsp, &hdr, msg_buf, &rem, &idx);
log_SNM_INFO(&rsp);
sn_num = process_snm_rsp(&sss->supernodes, &sss->communities,
&sender_sn, &hdr, &rsp);
/* send requests to the recently added supernodes */
new_sn = sss->supernodes.list_head;
while (sn_num > 0 && new_sn)
{
send_snm_req(sss, &new_sn->sn, 1, NULL, 0);
new_sn = new_sn->next;
sn_num--;
}
}
else if (msg_type == SNM_TYPE_ADV_MSG)
{
n2n_SNM_ADV_t adv;
int communities_updated = 0;
decode_SNM_ADV(&adv, &hdr, msg_buf, &rem, &idx);
log_SNM_ADV(&adv);
communities_updated = process_snm_adv(&sss->supernodes,
&sss->communities,
&sender_sn, &adv);
if (communities_updated && GET_A(hdr.flags))
{
/* sending supernode is requesting ADV */
send_snm_adv(sss, &sender_sn, sss->communities.list_head);
}
/* new supernode will be advertised on REG SUPER ACK */
}
return 0;
}
