static int default_transmission_control(struct dtp_ps * ps, struct pdu * pdu) { struct dtp * dtp = ps->dm; struct dt * dt; struct efcp * efcp; if (!dtp) { LOG_ERR("No instance passed, cannot run policy"); pdu_destroy(pdu); return -1; } dt = dtp_dt(dtp); if (!dt) { LOG_ERR("Passed instance has no parent, cannot run policy"); pdu_destroy(pdu); return -1; } efcp = dt_efcp(dt); if (!efcp) { LOG_ERR("Passed instance has no EFCP, cannot run policy"); pdu_destroy(pdu); return -1; } /* Post SDU to RMT */ LOG_DBG("defaultTxPolicy - sending to rmt"); if (dtp_sv_max_seq_nr_set(dtp, pci_sequence_number_get(pdu_pci_get_ro( pdu)))) LOG_ERR("Problems setting max sequence number received " "in default_transmission"); LOG_DBG("local_soft_irq_pending: %d", local_softirq_pending()); return common_efcp_pdu_send(efcp, dtp_rmt(dtp), pci_destination(pdu_pci_get_ro(pdu)), pci_qos_id(pdu_pci_get_ro(pdu)), pdu); }
/* Passing dt_cons already, for future work */ static int serialize_ctrl_seq(const struct serdes * instance, char * data, const struct pci * pci, int offset) { seq_num_t seq; struct dt_cons * dt_cons; ASSERT(instance); ASSERT(data); ASSERT(pci); ASSERT(offset); dt_cons = instance->dt_cons; ASSERT(dt_cons); seq = pci_sequence_number_get(pci); memcpy(data + offset, &seq, CTRL_SEQ_NR); return 0; }
int dtcp_ack_flow_control_pdu_send(struct dtcp * dtcp, seq_num_t seq) { struct pdu * pdu; pdu_type_t type; seq_num_t dbg_seq_num; if (!dtcp) { LOG_ERR("No instance passed, cannot run policy"); return -1; } atomic_inc(&dtcp->cpdus_in_transit); type = pdu_ctrl_type_get(dtcp, seq); if (!type) { atomic_dec(&dtcp->cpdus_in_transit); return 0; } pdu = pdu_ctrl_generate(dtcp, type); if (!pdu) { atomic_dec(&dtcp->cpdus_in_transit); return -1; } dbg_seq_num = pci_sequence_number_get(pdu_pci_get_rw(pdu)); LOG_DBG("DTCP Sending ACK (CPU: %d)", smp_processor_id()); dump_we(dtcp, pdu_pci_get_rw(pdu)); if (dtcp_pdu_send(dtcp, pdu)){ atomic_dec(&dtcp->cpdus_in_transit); return -1; } atomic_dec(&dtcp->cpdus_in_transit); return 0; }
void dump_we(struct dtcp * dtcp, struct pci * pci) { struct dtp * dtp; seq_num_t snd_rt_we; seq_num_t snd_lf_we; seq_num_t rcv_rt_we; seq_num_t rcv_lf_we; seq_num_t new_rt_we; seq_num_t new_lf_we; seq_num_t pci_seqn; seq_num_t my_rt_we; seq_num_t my_lf_we; seq_num_t ack; ASSERT(dtcp); ASSERT(pci); dtp = dt_dtp(dtcp->parent); ASSERT(dtp); snd_rt_we = snd_rt_wind_edge(dtcp); snd_lf_we = dtcp_snd_lf_win(dtcp); rcv_rt_we = rcvr_rt_wind_edge(dtcp); rcv_lf_we = dt_sv_rcv_lft_win(dtcp->parent); new_rt_we = pci_control_new_rt_wind_edge(pci); new_lf_we = pci_control_new_left_wind_edge(pci); my_lf_we = pci_control_my_left_wind_edge(pci); my_rt_we = pci_control_my_rt_wind_edge(pci); pci_seqn = pci_sequence_number_get(pci); ack = pci_control_ack_seq_num(pci); LOG_DBG("SEQN: %u N/Ack: %u SndRWE: %u SndLWE: %u " "RcvRWE: %u RcvLWE: %u " "newRWE: %u newLWE: %u " "myRWE: %u myLWE: %u", pci_seqn, ack, snd_rt_we, snd_lf_we, rcv_rt_we, rcv_lf_we, new_rt_we, new_lf_we, my_rt_we, my_lf_we); }
static struct pdu_ser * pdu_serialize_gfp(gfp_t flags, const const struct serdes * instance, struct pdu * pdu) { struct pdu_ser * tmp; struct dt_cons * dt_cons; const void * buffer_data; const struct buffer * buffer; const struct pci * pci; size_t size; ssize_t buffer_size; ssize_t pci_size; char * data; pdu_type_t pdu_type; seq_num_t seq; struct buffer * buf; if (!pdu_is_ok(pdu)) return NULL; if (!instance) return NULL; dt_cons = instance->dt_cons; ASSERT(dt_cons); buffer = pdu_buffer_get_ro(pdu); if (!buffer) return NULL; buffer_data = buffer_data_ro(buffer); if (!buffer_data) return NULL; buffer_size = buffer_length(buffer); if (buffer_size <= 0) return NULL; pci = pdu_pci_get_ro(pdu); if (!pci) return NULL; pdu_type = pci_type(pci); if (!pdu_type_is_ok(pdu_type)) { LOG_ERR("Wrong PDU type"); return NULL; } /* Base PCI size, fields present in all PDUs */ pci_size = base_pci_size(dt_cons); /* * These are available in the stack at this point in time * Extend if necessary (e.g.) NACKs, SACKs, ... * Set size in first switch/case */ switch (pdu_type) { case PDU_TYPE_MGMT: case PDU_TYPE_DT: size = pci_size + dt_cons->seq_num_length + buffer_size; if (size <= 0) return NULL; break; case PDU_TYPE_FC: size = pci_size + CTRL_SEQ_NR + fc_pci_size(dt_cons); if (size <= 0) return NULL; break; case PDU_TYPE_ACK: size = pci_size + CTRL_SEQ_NR + dt_cons->seq_num_length; if (size <= 0) return NULL; break; case PDU_TYPE_ACK_AND_FC: size = pci_size + CTRL_SEQ_NR + fc_pci_size(dt_cons) + dt_cons->seq_num_length; if (size <= 0) return NULL; break; case PDU_TYPE_CC: size = pci_size + 2 * CTRL_SEQ_NR + 4 * dt_cons->seq_num_length + RATE_LEN; if (size <= 0) return NULL; break; default: LOG_ERR("Unknown PDU type %02X", pdu_type); return NULL; } data = rkmalloc(size, flags); if (!data) return NULL; /* Needed for all PDUs */ if (serialize_base_pci(instance, data, pci, size)) { LOG_ERR("Failed to serialize base PCI"); rkfree(data); return NULL; } /* Do actual serializing in the second switch case */ switch (pdu_type) { case PDU_TYPE_MGMT: case PDU_TYPE_DT: seq = pci_sequence_number_get(pci); memcpy(data + pci_size, &seq, dt_cons->seq_num_length); memcpy(data + pci_size + dt_cons->seq_num_length, buffer_data, buffer_size); break; case PDU_TYPE_FC: if (serialize_ctrl_seq(instance, data, pci, pci_size) || serialize_fc_pci(instance, data, pci, pci_size + CTRL_SEQ_NR)) { rkfree(data); return NULL; } break; case PDU_TYPE_ACK: if (serialize_ctrl_seq(instance, data, pci, pci_size) || serialize_ack_pci(instance, data, pci, pci_size + CTRL_SEQ_NR)) { rkfree(data); return NULL; } break; case PDU_TYPE_ACK_AND_FC: if (serialize_ctrl_seq(instance, data, pci, pci_size) || serialize_ack_pci(instance, data, pci, pci_size + CTRL_SEQ_NR) || serialize_fc_pci(instance, data, pci, pci_size + CTRL_SEQ_NR + dt_cons->seq_num_length)) { rkfree(data); return NULL; } break; case PDU_TYPE_CC: if (serialize_ctrl_seq(instance, data, pci, pci_size) || serialize_cc_pci(instance, data, pci, pci_size + CTRL_SEQ_NR)) { rkfree(data); return NULL; } break; default: LOG_ERR("Unknown PDU type %02X", pdu_type); return NULL; } buf = buffer_create_with_gfp(flags, data, size); if (!buf) { rkfree(data); return NULL; } tmp = pdu_ser_create_buffer_with_gfp(flags, buf); if (!tmp) { rkfree(buf); return NULL; } pdu_destroy(pdu); return tmp; }
int dtcp_common_rcv_control(struct dtcp * dtcp, struct pdu * pdu) { struct dtcp_ps * ps; struct pci * pci; pdu_type_t type; seq_num_t sn; seq_num_t last_ctrl; int ret; LOG_DBG("dtcp_common_rcv_control called"); if (!pdu_is_ok(pdu)) { LOG_ERR("PDU is not ok"); pdu_destroy(pdu); return -1; } if (!dtcp) { LOG_ERR("DTCP instance bogus"); pdu_destroy(pdu); return -1; } atomic_inc(&dtcp->cpdus_in_transit); pci = pdu_pci_get_rw(pdu); if (!pci_is_ok(pci)) { LOG_ERR("PCI couldn't be retrieved"); atomic_dec(&dtcp->cpdus_in_transit); pdu_destroy(pdu); return -1; } type = pci_type(pci); if (!pdu_type_is_control(type)) { LOG_ERR("CommonRCVControl policy received a non-control PDU"); atomic_dec(&dtcp->cpdus_in_transit); pdu_destroy(pdu); return -1; } sn = pci_sequence_number_get(pci); last_ctrl = last_rcv_ctrl_seq(dtcp); if (sn <= last_ctrl) { switch (type) { case PDU_TYPE_FC: flow_ctrl_inc(dtcp); break; case PDU_TYPE_ACK: acks_inc(dtcp); break; case PDU_TYPE_ACK_AND_FC: acks_inc(dtcp); flow_ctrl_inc(dtcp); break; default: break; } pdu_destroy(pdu); return 0; } rcu_read_lock(); ps = container_of(rcu_dereference(dtcp->base.ps), struct dtcp_ps, base); if (sn > (last_ctrl + 1)) { ps->lost_control_pdu(ps); } rcu_read_unlock(); /* We are in sn >= last_ctrl + 1 */ last_rcv_ctrl_seq_set(dtcp, sn); LOG_DBG("dtcp_common_rcv_control sending to proper function..."); switch (type) { case PDU_TYPE_ACK: ret = rcv_ack(dtcp, pdu); break; case PDU_TYPE_NACK: ret = rcv_nack_ctl(dtcp, pdu); break; case PDU_TYPE_FC: ret = rcv_flow_ctl(dtcp, pdu); break; case PDU_TYPE_ACK_AND_FC: ret = rcv_ack_and_flow_ctl(dtcp, pdu); break; default: ret = -1; break; } atomic_dec(&dtcp->cpdus_in_transit); return ret; }
static struct pdu_ser * pdu_serialize_gfp(gfp_t flags, const const struct serdes * instance, struct pdu * pdu, struct dup_config_entry * dup_conf, struct crypto_blkcipher * blkcipher) { struct pdu_ser * tmp; struct dt_cons * dt_cons; const void * buffer_data; const struct buffer * buffer; const struct pci * pci; size_t size; ssize_t buffer_size; ssize_t blk_size; ssize_t encrypted_size; ssize_t pci_size; char * data; pdu_type_t pdu_type; seq_num_t seq; struct buffer * buf; int i; if (!pdu_is_ok(pdu)) return NULL; if (!instance) return NULL; dt_cons = instance->dt_cons; ASSERT(dt_cons); buffer = pdu_buffer_get_ro(pdu); if (!buffer) return NULL; buffer_data = buffer_data_ro(buffer); if (!buffer_data) return NULL; buffer_size = buffer_length(buffer); if (buffer_size <= 0) return NULL; pci = pdu_pci_get_ro(pdu); if (!pci) return NULL; pdu_type = pci_type(pci); if (!pdu_type_is_ok(pdu_type)) { LOG_ERR("Wrong PDU type"); return NULL; } /* Base PCI size, fields present in all PDUs */ pci_size = base_pci_size(dt_cons); /* * These are available in the stack at this point in time * Extend if necessary (e.g.) NACKs, SACKs, ... * Set size in first switch/case */ switch (pdu_type) { case PDU_TYPE_MGMT: case PDU_TYPE_DT: size = pci_size + dt_cons->seq_num_length + buffer_size; if (size <= 0) return NULL; break; case PDU_TYPE_FC: size = pci_size + CTRL_SEQ_NR + fc_pci_size(dt_cons); if (size <= 0) return NULL; break; case PDU_TYPE_ACK: size = pci_size + CTRL_SEQ_NR + dt_cons->seq_num_length; if (size <= 0) return NULL; break; case PDU_TYPE_ACK_AND_FC: size = pci_size + CTRL_SEQ_NR + fc_pci_size(dt_cons) + dt_cons->seq_num_length; if (size <= 0) return NULL; break; case PDU_TYPE_CACK: size = pci_size + 2 * CTRL_SEQ_NR + 4 * dt_cons->seq_num_length + RATE_LEN; if (size <= 0) return NULL; break; default: LOG_ERR("Unknown PDU type %02X", pdu_type); return NULL; } data = rkmalloc(size, flags); if (!data) return NULL; /* Needed for all PDUs */ if (serialize_base_pci(instance, data, pci, size)) { LOG_ERR("Failed to serialize base PCI"); rkfree(data); return NULL; } /* Do actual serializing in the second switch case */ switch (pdu_type) { case PDU_TYPE_MGMT: case PDU_TYPE_DT: seq = pci_sequence_number_get(pci); memcpy(data + pci_size, &seq, dt_cons->seq_num_length); memcpy(data + pci_size + dt_cons->seq_num_length, buffer_data, buffer_size); break; case PDU_TYPE_FC: if (serialize_ctrl_seq(instance, data, pci, pci_size) || serialize_fc_pci(instance, data, pci, pci_size + CTRL_SEQ_NR)) { rkfree(data); return NULL; } break; case PDU_TYPE_ACK: if (serialize_ctrl_seq(instance, data, pci, pci_size) || serialize_ack_pci(instance, data, pci, pci_size + CTRL_SEQ_NR)) { rkfree(data); return NULL; } break; case PDU_TYPE_ACK_AND_FC: if (serialize_ctrl_seq(instance, data, pci, pci_size) || serialize_ack_pci(instance, data, pci, pci_size + CTRL_SEQ_NR) || serialize_fc_pci(instance, data, pci, pci_size + CTRL_SEQ_NR + dt_cons->seq_num_length)) { rkfree(data); return NULL; } break; case PDU_TYPE_CACK: if (serialize_ctrl_seq(instance, data, pci, pci_size) || serialize_cc_pci(instance, data, pci, pci_size + CTRL_SEQ_NR)) { rkfree(data); return NULL; } break; default: LOG_ERR("Unknown PDU type %02X", pdu_type); return NULL; } buf = buffer_create_with_gfp(flags, data, size); if (!buf) { rkfree(data); return NULL; } tmp = pdu_ser_create_buffer_with_gfp(flags, buf); if (!tmp) { rkfree(buf); return NULL; } /* FIXME: this should be moved to specific policy code */ if (dup_conf != NULL && dup_conf->ttl_policy != NULL){ if (pdu_ser_head_grow_gfp(flags, tmp, sizeof(u8))) { LOG_ERR("Failed to grow ser PDU"); pdu_ser_destroy(tmp); return NULL; } if (!dup_ttl_set(tmp, pci_ttl(pci))) { LOG_ERR("Could not set TTL"); pdu_ser_destroy(tmp); return NULL; } if (dup_ttl_is_expired(tmp)) { LOG_DBG("TTL is expired, dropping PDU"); pdu_ser_destroy(tmp); return NULL; } } /* FIXME: this should be moved to specific policy code */ if (blkcipher != NULL && dup_conf != NULL && dup_conf->enable_encryption){ buf = pdu_ser_buffer(tmp); blk_size = crypto_blkcipher_blocksize(blkcipher); buffer_size = buffer_length(buf); encrypted_size = (buffer_size/blk_size + 1) * blk_size; if (pdu_ser_tail_grow_gfp(tmp, encrypted_size - buffer_size)){ LOG_ERR("Failed to grow ser PDU"); pdu_ser_destroy(tmp); return NULL; } /* PADDING */ data = buffer_data_rw(buf); for (i=encrypted_size-1; i>buffer_size; i--){ data[i] = encrypted_size - buffer_size; } /* Encrypt */ if (!dup_encrypt_data(tmp, blkcipher)) { LOG_ERR("Failed to encrypt PDU"); pdu_ser_destroy(tmp); return NULL; } } /* FIXME: this should be moved to specific policy code */ if (dup_conf != NULL && dup_conf->error_check_policy != NULL){ /* Assuming CRC32 */ if (pdu_ser_head_grow_gfp(flags, tmp, sizeof(u32))) { LOG_ERR("Failed to grow ser PDU"); pdu_ser_destroy(tmp); return NULL; } if (!dup_chksum_set(tmp)) { LOG_ERR("Failed to add CRC"); pdu_ser_destroy(tmp); return NULL; } ASSERT(dup_chksum_is_ok(tmp)); } return tmp; }