maki/openairinterface5g
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

remove L1L2 task, also remove some call to send messages to UNKNOWN_TASK, removed in new itti. Align LOG in rlc sources with new LOG code (remove DEBUG_RLC...)

Browse Source
This commit is contained in:
frtabu
2019-01-21 19:43:19 +01:00
parent 24bde5d635
commit 9d0c70c9fe
20 changed files with 5332 additions and 7031 deletions
Download Patch File Download Diff File Expand all files Collapse all files
common/utils/LOG/log.h
+2
View File
@@ -145,6 +145,7 @@ extern "C" {
#define DEBUG_CTRLSOCKET (1<<10) #define DEBUG_CTRLSOCKET (1<<10)
#define DEBUG_SECURITY (1<<11) #define DEBUG_SECURITY (1<<11)
#define DEBUG_NAS (1<<12) #define DEBUG_NAS (1<<12)
#define DEBUG_RLC (1<<13)
#define UE_TIMING (1<<20) #define UE_TIMING (1<<20)
@@ -162,6 +163,7 @@ extern "C" {
{"CTRLSOCKET", DEBUG_CTRLSOCKET},\ {"CTRLSOCKET", DEBUG_CTRLSOCKET},\
{"SECURITY", DEBUG_SECURITY},\ {"SECURITY", DEBUG_SECURITY},\
{"NAS", DEBUG_NAS},\ {"NAS", DEBUG_NAS},\
{"RLC", DEBUG_RLC},\
{"UE_TIMING", UE_TIMING},\ {"UE_TIMING", UE_TIMING},\
{NULL,-1}\ {NULL,-1}\
} }
common/utils/msc/msc.h
+2
View File
@@ -108,6 +108,8 @@ void msc_log_message(
#else #else
#define MESSAGE_CHART_GENERATOR msc_interface.msc_loaded
msc_interface_t msc_interface; msc_interface_t msc_interface;
#define MSC_INIT(arg1,arg2) if(msc_interface.msc_loaded) msc_interface.msc_init(arg1,arg2) #define MSC_INIT(arg1,arg2) if(msc_interface.msc_loaded) msc_interface.msc_init(arg1,arg2)
#define MSC_START_USE if(msc_interface.msc_loaded) msc_interface.msc_start_use #define MSC_START_USE if(msc_interface.msc_loaded) msc_interface.msc_start_use
openair2/COMMON/tasks_def.h
-12
View File
@@ -25,18 +25,11 @@ TASK_DEF(TASK_TIMER, TASK_PRIORITY_MAX, 10)
// Other possible tasks in the process // Other possible tasks in the process
// Common tasks: // Common tasks:
/// Layer 2 and Layer 1 task supporting all the synchronous processing
TASK_DEF(TASK_L2L1, TASK_PRIORITY_MAX_LEAST, 200)
/// Bearers Manager task /// Bearers Manager task
TASK_DEF(TASK_BM, TASK_PRIORITY_MED, 200) TASK_DEF(TASK_BM, TASK_PRIORITY_MED, 200)
// eNodeB tasks and sub-tasks: // eNodeB tasks and sub-tasks:
//// Layer 2 and Layer 1 sub-tasks
SUB_TASK_DEF(TASK_L2L1, TASK_PHY_ENB, 200)
SUB_TASK_DEF(TASK_L2L1, TASK_MAC_ENB, 200)
SUB_TASK_DEF(TASK_L2L1, TASK_RLC_ENB, 200)
SUB_TASK_DEF(TASK_L2L1, TASK_PDCP_ENB, 200)
/// Radio Resource Control task /// Radio Resource Control task
TASK_DEF(TASK_RRC_ENB, TASK_PRIORITY_MED, 200) TASK_DEF(TASK_RRC_ENB, TASK_PRIORITY_MED, 200)
@@ -63,11 +56,6 @@ TASK_DEF(TASK_ENB_APP, TASK_PRIORITY_MED, 200)
TASK_DEF(TASK_FLEXRAN_AGENT, TASK_PRIORITY_MED, 200) TASK_DEF(TASK_FLEXRAN_AGENT, TASK_PRIORITY_MED, 200)
// UE tasks and sub-tasks: // UE tasks and sub-tasks:
//// Layer 2 and Layer 1 sub-tasks
SUB_TASK_DEF(TASK_L2L1, TASK_PHY_UE, 200)
SUB_TASK_DEF(TASK_L2L1, TASK_MAC_UE, 200)
SUB_TASK_DEF(TASK_L2L1, TASK_RLC_UE, 200)
SUB_TASK_DEF(TASK_L2L1, TASK_PDCP_UE, 200)
/// Radio Resource Control task /// Radio Resource Control task
TASK_DEF(TASK_RRC_UE, TASK_PRIORITY_MED, 200) TASK_DEF(TASK_RRC_UE, TASK_PRIORITY_MED, 200)
openair2/LAYER2/RLC/AM_v9.3.0/rlc_am.c
+80 -219
View File
@@ -25,9 +25,7 @@
#include "platform_types.h" #include "platform_types.h"
#include "platform_constants.h" #include "platform_constants.h"
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
#if ENABLE_ITTI
# include "intertask_interface.h"
#endif
#include "assertions.h" #include "assertions.h"
#include "msc.h" #include "msc.h"
#include "hashtable.h" #include "hashtable.h"
@@ -47,31 +45,24 @@
uint32_t uint32_t
rlc_am_get_status_pdu_buffer_occupancy( rlc_am_get_status_pdu_buffer_occupancy(
rlc_am_entity_t *const rlc_pP) { rlc_am_entity_t *const rlc_pP) {
//Compute Max Status PDU size according to what has been received and not received in the window [vrR vrMS[ //Compute Max Status PDU size according to what has been received and not received in the window [vrR vrMS[
// minimum header size in bits to be transmitted: D/C + CPT + ACK_SN + E1 // minimum header size in bits to be transmitted: D/C + CPT + ACK_SN + E1
uint32_t nb_bits_to_transmit = RLC_AM_PDU_D_C_BITS + RLC_AM_STATUS_PDU_CPT_LENGTH + RLC_AM_SN_BITS + RLC_AM_PDU_E_BITS; uint32_t nb_bits_to_transmit = RLC_AM_PDU_D_C_BITS + RLC_AM_STATUS_PDU_CPT_LENGTH + RLC_AM_SN_BITS + RLC_AM_PDU_E_BITS;
mem_block_t *cursor_p = rlc_pP->receiver_buffer.head; mem_block_t *cursor_p = rlc_pP->receiver_buffer.head;
rlc_am_pdu_info_t *pdu_info_cursor_p = NULL; rlc_am_pdu_info_t *pdu_info_cursor_p = NULL;
int waited_so = 0; int waited_so = 0;
rlc_sn_t sn_cursor = rlc_pP->vr_r; rlc_sn_t sn_cursor = rlc_pP->vr_r;
rlc_sn_t sn_prev = rlc_pP->vr_r; rlc_sn_t sn_prev = rlc_pP->vr_r;
rlc_sn_t sn_end = rlc_pP->vr_ms; rlc_sn_t sn_end = rlc_pP->vr_ms;
boolean_t segment_loop_end = false; boolean_t segment_loop_end = false;
if (sn_prev != sn_end) {
if (sn_prev != sn_end) while ((RLC_AM_DIFF_SN(sn_prev,rlc_pP->vr_r) < RLC_AM_DIFF_SN(sn_end,rlc_pP->vr_r)) && (cursor_p != NULL)) {
{
while ((RLC_AM_DIFF_SN(sn_prev,rlc_pP->vr_r) < RLC_AM_DIFF_SN(sn_end,rlc_pP->vr_r)) && (cursor_p != NULL))
{
pdu_info_cursor_p = &((rlc_am_rx_pdu_management_t *)(cursor_p->data))->pdu_info; pdu_info_cursor_p = &((rlc_am_rx_pdu_management_t *)(cursor_p->data))->pdu_info;
sn_cursor = pdu_info_cursor_p->sn; sn_cursor = pdu_info_cursor_p->sn;
// Add holes between sn_prev and sn_cursor // Add holes between sn_prev and sn_cursor
while ((sn_prev != sn_cursor) && (sn_prev != sn_end)) while ((sn_prev != sn_cursor) && (sn_prev != sn_end)) {
{
/* Add 1 NACK_SN + E1 + E2 */ /* Add 1 NACK_SN + E1 + E2 */
nb_bits_to_transmit += (RLC_AM_SN_BITS + (RLC_AM_PDU_E_BITS << 1)); nb_bits_to_transmit += (RLC_AM_SN_BITS + (RLC_AM_PDU_E_BITS << 1));
sn_prev = RLC_AM_NEXT_SN(sn_prev); sn_prev = RLC_AM_NEXT_SN(sn_prev);
@@ -79,8 +70,7 @@ rlc_am_get_status_pdu_buffer_occupancy(
/* Handle case sn_cursor is partially received */ /* Handle case sn_cursor is partially received */
/* Each gap will add NACK_SN + E1 + E2 + SOStart + SOEnd */ /* Each gap will add NACK_SN + E1 + E2 + SOStart + SOEnd */
if ((((rlc_am_rx_pdu_management_t*)(cursor_p->data))->all_segments_received == 0) && (RLC_AM_DIFF_SN(sn_cursor,rlc_pP->vr_r) < RLC_AM_DIFF_SN(sn_end,rlc_pP->vr_r))) if ((((rlc_am_rx_pdu_management_t *)(cursor_p->data))->all_segments_received == 0) && (RLC_AM_DIFF_SN(sn_cursor,rlc_pP->vr_r) < RLC_AM_DIFF_SN(sn_end,rlc_pP->vr_r))) {
{
/* Check lsf */ /* Check lsf */
segment_loop_end = (pdu_info_cursor_p->lsf == 1); segment_loop_end = (pdu_info_cursor_p->lsf == 1);
@@ -88,30 +78,26 @@ rlc_am_get_status_pdu_buffer_occupancy(
if (pdu_info_cursor_p->so) { if (pdu_info_cursor_p->so) {
nb_bits_to_transmit += (RLC_AM_SN_BITS + (RLC_AM_PDU_E_BITS << 1) + (RLC_AM_STATUS_PDU_SO_LENGTH << 1)); nb_bits_to_transmit += (RLC_AM_SN_BITS + (RLC_AM_PDU_E_BITS << 1) + (RLC_AM_STATUS_PDU_SO_LENGTH << 1));
waited_so = pdu_info_cursor_p->so + pdu_info_cursor_p->payload_size; waited_so = pdu_info_cursor_p->so + pdu_info_cursor_p->payload_size;
} } else {
else {
waited_so = pdu_info_cursor_p->payload_size; waited_so = pdu_info_cursor_p->payload_size;
} }
/* Go to next segment */ /* Go to next segment */
cursor_p = cursor_p->next; cursor_p = cursor_p->next;
if (cursor_p != NULL)
{ if (cursor_p != NULL) {
pdu_info_cursor_p = &((rlc_am_rx_pdu_management_t *)(cursor_p->data))->pdu_info; pdu_info_cursor_p = &((rlc_am_rx_pdu_management_t *)(cursor_p->data))->pdu_info;
} }
/* Fill following gaps if any */ /* Fill following gaps if any */
while (!segment_loop_end) while (!segment_loop_end) {
{ if ((cursor_p != NULL) && (pdu_info_cursor_p->sn == sn_cursor)) {
if ((cursor_p != NULL) && (pdu_info_cursor_p->sn == sn_cursor))
{
/* Check lsf */ /* Check lsf */
segment_loop_end = (pdu_info_cursor_p->lsf == 1); segment_loop_end = (pdu_info_cursor_p->lsf == 1);
if (waited_so < pdu_info_cursor_p->so) { if (waited_so < pdu_info_cursor_p->so) {
nb_bits_to_transmit += (RLC_AM_SN_BITS + (RLC_AM_PDU_E_BITS << 1) + (RLC_AM_STATUS_PDU_SO_LENGTH << 1)); nb_bits_to_transmit += (RLC_AM_SN_BITS + (RLC_AM_PDU_E_BITS << 1) + (RLC_AM_STATUS_PDU_SO_LENGTH << 1));
} } else {
else {
/* contiguous segment: only update waited_so */ /* contiguous segment: only update waited_so */
/* Assuming so and payload_size updated according to duplication removal done at reception ... */ /* Assuming so and payload_size updated according to duplication removal done at reception ... */
waited_so += pdu_info_cursor_p->payload_size; waited_so += pdu_info_cursor_p->payload_size;
@@ -119,24 +105,20 @@ rlc_am_get_status_pdu_buffer_occupancy(
/* Go to next received PDU or PDU Segment */ /* Go to next received PDU or PDU Segment */
cursor_p = cursor_p->next; cursor_p = cursor_p->next;
if (cursor_p != NULL)
{ if (cursor_p != NULL) {
pdu_info_cursor_p = &((rlc_am_rx_pdu_management_t *)(cursor_p->data))->pdu_info; pdu_info_cursor_p = &((rlc_am_rx_pdu_management_t *)(cursor_p->data))->pdu_info;
} }
} } else {
else
{
/* Fill last gap assuming LSF is not received */ /* Fill last gap assuming LSF is not received */
nb_bits_to_transmit += (RLC_AM_SN_BITS + (RLC_AM_PDU_E_BITS << 1) + (RLC_AM_STATUS_PDU_SO_LENGTH << 1)); nb_bits_to_transmit += (RLC_AM_SN_BITS + (RLC_AM_PDU_E_BITS << 1) + (RLC_AM_STATUS_PDU_SO_LENGTH << 1));
segment_loop_end = true; segment_loop_end = true;
} }
} // end while (!segment_loop_end) } // end while (!segment_loop_end)
} // end if segments } // end if segments
else else {
{
/* Go to next received PDU or PDU segment with different SN */ /* Go to next received PDU or PDU segment with different SN */
do do {
{
cursor_p = cursor_p->next; cursor_p = cursor_p->next;
} while ((cursor_p != NULL) && (((rlc_am_rx_pdu_management_t *)(cursor_p->data))->pdu_info.sn == sn_cursor)); } while ((cursor_p != NULL) && (((rlc_am_rx_pdu_management_t *)(cursor_p->data))->pdu_info.sn == sn_cursor));
} }
@@ -147,43 +129,36 @@ rlc_am_get_status_pdu_buffer_occupancy(
// round up to the greatest byte // round up to the greatest byte
return ((nb_bits_to_transmit + 7) >> 3); return ((nb_bits_to_transmit + 7) >> 3);
} }
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
uint32_t uint32_t
rlc_am_get_buffer_occupancy_in_bytes ( rlc_am_get_buffer_occupancy_in_bytes (
const protocol_ctxt_t *const ctxt_pP, const protocol_ctxt_t *const ctxt_pP,
rlc_am_entity_t * const rlc_pP) rlc_am_entity_t *const rlc_pP) {
{
// priority of control trafic // priority of control trafic
rlc_pP->status_buffer_occupancy = 0; rlc_pP->status_buffer_occupancy = 0;
if ((rlc_pP->status_requested) && !(rlc_pP->status_requested & RLC_AM_STATUS_NO_TX_MASK)) { if ((rlc_pP->status_requested) && !(rlc_pP->status_requested & RLC_AM_STATUS_NO_TX_MASK)) {
rlc_pP->status_buffer_occupancy = rlc_am_get_status_pdu_buffer_occupancy(rlc_pP); rlc_pP->status_buffer_occupancy = rlc_am_get_status_pdu_buffer_occupancy(rlc_pP);
#if TRACE_RLC_AM_BO LOG_D(RLC, PROTOCOL_RLC_AM_CTXT_FMT" BO : CONTROL PDU %d bytes \n",
LOG_D(RLC, PROTOCOL_CTXT_FMT RB_AM_FMT" BO : CONTROL PDU %d bytes \n",
PROTOCOL_RLC_AM_CTXT_ARGS(ctxt_pP,rlc_pP), PROTOCOL_RLC_AM_CTXT_ARGS(ctxt_pP,rlc_pP),
rlc_pP->status_buffer_occupancy); rlc_pP->status_buffer_occupancy);
#endif
} }
if ( LOG_DEBUGFLAG(DEBUG_RLC)) {
#if TRACE_RLC_AM_BO if ((rlc_pP->status_buffer_occupancy + rlc_pP->retrans_num_bytes_to_retransmit + rlc_pP->sdu_buffer_occupancy ) > 0) {
LOG_UI(RLC, PROTOCOL_RLC_AM_CTXT_FMT" BO : STATUS BUFFER %d bytes \n", PROTOCOL_RLC_AM_CTXT_ARGS(ctxt_pP,rlc_pP), rlc_pP->status_buffer_occupancy);
if ((rlc_pP->status_buffer_occupancy + rlc_pP->retrans_num_bytes_to_retransmit + rlc_pP->sdu_buffer_occupancy + max_li_overhead + header_overhead) > 0) { LOG_UI(RLC, PROTOCOL_RLC_AM_CTXT_FMT" BO : RETRANS BUFFER %d bytes \n", PROTOCOL_RLC_AM_CTXT_ARGS(ctxt_pP,rlc_pP), rlc_pP->retrans_num_bytes_to_retransmit);
LOG_D(RLC, PROTOCOL_RLC_AM_CTXT_FMT" BO : STATUS BUFFER %d bytes \n", PROTOCOL_RLC_AM_CTXT_ARGS(ctxt_pP,rlc_pP), rlc_pP->status_buffer_occupancy); LOG_UI(RLC, PROTOCOL_RLC_AM_CTXT_FMT" BO : SDU BUFFER %d bytes + li_overhead %d bytes header_overhead %d bytes (nb sdu not segmented %d)\n",
LOG_D(RLC, PROTOCOL_RLC_AM_CTXT_FMT" BO : RETRANS BUFFER %d bytes \n", PROTOCOL_RLC_AM_CTXT_ARGS(ctxt_pP,rlc_pP), rlc_pP->retrans_num_bytes_to_retransmit);
LOG_D(RLC, PROTOCOL_RLC_AM_CTXT_FMT" BO : SDU BUFFER %d bytes + li_overhead %d bytes header_overhead %d bytes (nb sdu not segmented %d)\n",
PROTOCOL_RLC_AM_CTXT_ARGS(ctxt_pP,rlc_pP), PROTOCOL_RLC_AM_CTXT_ARGS(ctxt_pP,rlc_pP),
rlc_pP->sdu_buffer_occupancy, rlc_pP->sdu_buffer_occupancy,
0, 0,
0, 0,
rlc_pP->nb_sdu_no_segmented); rlc_pP->nb_sdu_no_segmented);
} }
}
#endif
return rlc_pP->status_buffer_occupancy + rlc_pP->retrans_num_bytes_to_retransmit + rlc_pP->sdu_buffer_occupancy; return rlc_pP->status_buffer_occupancy + rlc_pP->retrans_num_bytes_to_retransmit + rlc_pP->sdu_buffer_occupancy;
} }
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
@@ -191,8 +166,7 @@ void
rlc_am_release ( rlc_am_release (
const protocol_ctxt_t *const ctxt_pP, const protocol_ctxt_t *const ctxt_pP,
rlc_am_entity_t *const rlc_pP rlc_am_entity_t *const rlc_pP
) ) {
{
// empty // empty
} }
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
@@ -203,13 +177,11 @@ config_req_rlc_am (
const rlc_am_info_t *config_am_pP, const rlc_am_info_t *config_am_pP,
const rb_id_t rb_idP, const rb_id_t rb_idP,
const logical_chan_id_t chan_idP const logical_chan_id_t chan_idP
) ) {
{
rlc_union_t *rlc_union_p = NULL; rlc_union_t *rlc_union_p = NULL;
rlc_am_entity_t *l_rlc_p = NULL; rlc_am_entity_t *l_rlc_p = NULL;
hash_key_t key = RLC_COLL_KEY_VALUE(ctxt_pP->module_id, ctxt_pP->rnti, ctxt_pP->enb_flag, rb_idP, srb_flagP); hash_key_t key = RLC_COLL_KEY_VALUE(ctxt_pP->module_id, ctxt_pP->rnti, ctxt_pP->enb_flag, rb_idP, srb_flagP);
hashtable_rc_t h_rc; hashtable_rc_t h_rc;
h_rc = hashtable_get(rlc_coll_p, key, (void **)&rlc_union_p); h_rc = hashtable_get(rlc_coll_p, key, (void **)&rlc_union_p);
if (h_rc == HASH_TABLE_OK) { if (h_rc == HASH_TABLE_OK) {
@@ -256,13 +228,11 @@ void config_req_rlc_am_asn1 (
const srb_flag_t srb_flagP, const srb_flag_t srb_flagP,
const struct LTE_RLC_Config__am *const config_am_pP, const struct LTE_RLC_Config__am *const config_am_pP,
const rb_id_t rb_idP, const rb_id_t rb_idP,
const logical_chan_id_t chan_idP) const logical_chan_id_t chan_idP) {
{
rlc_union_t *rlc_union_p = NULL; rlc_union_t *rlc_union_p = NULL;
rlc_am_entity_t *l_rlc_p = NULL; rlc_am_entity_t *l_rlc_p = NULL;
hash_key_t key = RLC_COLL_KEY_VALUE(ctxt_pP->module_id, ctxt_pP->rnti, ctxt_pP->enb_flag, rb_idP, srb_flagP); hash_key_t key = RLC_COLL_KEY_VALUE(ctxt_pP->module_id, ctxt_pP->rnti, ctxt_pP->enb_flag, rb_idP, srb_flagP);
hashtable_rc_t h_rc; hashtable_rc_t h_rc;
h_rc = hashtable_get(rlc_coll_p, key, (void **)&rlc_union_p); h_rc = hashtable_get(rlc_coll_p, key, (void **)&rlc_union_p);
if (h_rc == HASH_TABLE_OK) { if (h_rc == HASH_TABLE_OK) {
@@ -280,7 +250,6 @@ void config_req_rlc_am_asn1 (
(config_am_pP->dl_AM_RLC.t_Reordering<LTE_T_Reordering_spare1) && (config_am_pP->dl_AM_RLC.t_Reordering<LTE_T_Reordering_spare1) &&
(config_am_pP->dl_AM_RLC.t_StatusProhibit<LTE_T_StatusProhibit_spare8) ) { (config_am_pP->dl_AM_RLC.t_StatusProhibit<LTE_T_StatusProhibit_spare8) ) {
#endif #endif
MSC_LOG_RX_MESSAGE( MSC_LOG_RX_MESSAGE(
(ctxt_pP->enb_flag == ENB_FLAG_YES) ? MSC_RLC_ENB:MSC_RLC_UE, (ctxt_pP->enb_flag == ENB_FLAG_YES) ? MSC_RLC_ENB:MSC_RLC_UE,
(ctxt_pP->enb_flag == ENB_FLAG_YES) ? MSC_RRC_ENB:MSC_RRC_UE, (ctxt_pP->enb_flag == ENB_FLAG_YES) ? MSC_RRC_ENB:MSC_RRC_UE,
@@ -292,7 +261,6 @@ void config_req_rlc_am_asn1 (
PollRetransmit_tab[config_am_pP->ul_AM_RLC.t_PollRetransmit], PollRetransmit_tab[config_am_pP->ul_AM_RLC.t_PollRetransmit],
am_t_Reordering_tab[config_am_pP->dl_AM_RLC.t_Reordering], am_t_Reordering_tab[config_am_pP->dl_AM_RLC.t_Reordering],
t_StatusProhibit_tab[config_am_pP->dl_AM_RLC.t_StatusProhibit]); t_StatusProhibit_tab[config_am_pP->dl_AM_RLC.t_StatusProhibit]);
LOG_D(RLC, PROTOCOL_RLC_AM_CTXT_FMT" CONFIG_REQ (max_retx_threshold=%d poll_pdu=%d poll_byte=%d t_poll_retransmit=%d t_reord=%d t_status_prohibit=%d)\n", LOG_D(RLC, PROTOCOL_RLC_AM_CTXT_FMT" CONFIG_REQ (max_retx_threshold=%d poll_pdu=%d poll_byte=%d t_poll_retransmit=%d t_reord=%d t_status_prohibit=%d)\n",
PROTOCOL_RLC_AM_CTXT_ARGS(ctxt_pP,l_rlc_p), PROTOCOL_RLC_AM_CTXT_ARGS(ctxt_pP,l_rlc_p),
maxRetxThreshold_tab[config_am_pP->ul_AM_RLC.maxRetxThreshold], maxRetxThreshold_tab[config_am_pP->ul_AM_RLC.maxRetxThreshold],
@@ -301,7 +269,6 @@ void config_req_rlc_am_asn1 (
PollRetransmit_tab[config_am_pP->ul_AM_RLC.t_PollRetransmit], PollRetransmit_tab[config_am_pP->ul_AM_RLC.t_PollRetransmit],
am_t_Reordering_tab[config_am_pP->dl_AM_RLC.t_Reordering], am_t_Reordering_tab[config_am_pP->dl_AM_RLC.t_Reordering],
t_StatusProhibit_tab[config_am_pP->dl_AM_RLC.t_StatusProhibit]); t_StatusProhibit_tab[config_am_pP->dl_AM_RLC.t_StatusProhibit]);
rlc_am_init(ctxt_pP, l_rlc_p); rlc_am_init(ctxt_pP, l_rlc_p);
rlc_am_set_debug_infos(ctxt_pP, l_rlc_p, srb_flagP, rb_idP, chan_idP); rlc_am_set_debug_infos(ctxt_pP, l_rlc_p, srb_flagP, rb_idP, chan_idP);
rlc_am_configure(ctxt_pP, l_rlc_p, rlc_am_configure(ctxt_pP, l_rlc_p,
@@ -311,7 +278,8 @@ void config_req_rlc_am_asn1 (
PollRetransmit_tab[config_am_pP->ul_AM_RLC.t_PollRetransmit], PollRetransmit_tab[config_am_pP->ul_AM_RLC.t_PollRetransmit],
am_t_Reordering_tab[config_am_pP->dl_AM_RLC.t_Reordering], am_t_Reordering_tab[config_am_pP->dl_AM_RLC.t_Reordering],
t_StatusProhibit_tab[config_am_pP->dl_AM_RLC.t_StatusProhibit]); t_StatusProhibit_tab[config_am_pP->dl_AM_RLC.t_StatusProhibit]);
} else { }
else {
MSC_LOG_RX_DISCARDED_MESSAGE( MSC_LOG_RX_DISCARDED_MESSAGE(
(ctxt_pP->enb_flag == ENB_FLAG_YES) ? MSC_RLC_ENB:MSC_RLC_UE, (ctxt_pP->enb_flag == ENB_FLAG_YES) ? MSC_RLC_ENB:MSC_RLC_UE,
(ctxt_pP->enb_flag == ENB_FLAG_YES) ? MSC_RRC_ENB:MSC_RRC_UE, (ctxt_pP->enb_flag == ENB_FLAG_YES) ? MSC_RRC_ENB:MSC_RRC_UE,
@@ -320,7 +288,6 @@ void config_req_rlc_am_asn1 (
MSC_AS_TIME_FMT" "PROTOCOL_RLC_AM_MSC_FMT" CONFIG-REQ", MSC_AS_TIME_FMT" "PROTOCOL_RLC_AM_MSC_FMT" CONFIG-REQ",
MSC_AS_TIME_ARGS(ctxt_pP), MSC_AS_TIME_ARGS(ctxt_pP),
PROTOCOL_RLC_AM_MSC_ARGS(ctxt_pP, l_rlc_p)); PROTOCOL_RLC_AM_MSC_ARGS(ctxt_pP, l_rlc_p));
LOG_D(RLC, LOG_D(RLC,
PROTOCOL_RLC_AM_CTXT_FMT"ILLEGAL CONFIG_REQ (max_retx_threshold=%ld poll_pdu=%ld poll_byte=%ld t_poll_retransmit=%ld t_reord=%ld t_status_prohibit=%ld), RLC-AM NOT CONFIGURED\n", PROTOCOL_RLC_AM_CTXT_FMT"ILLEGAL CONFIG_REQ (max_retx_threshold=%ld poll_pdu=%ld poll_byte=%ld t_poll_retransmit=%ld t_reord=%ld t_status_prohibit=%ld), RLC-AM NOT CONFIGURED\n",
PROTOCOL_RLC_AM_CTXT_ARGS(ctxt_pP,l_rlc_p), PROTOCOL_RLC_AM_CTXT_ARGS(ctxt_pP,l_rlc_p),
@@ -367,8 +334,7 @@ void rlc_am_stat_req (
unsigned int *stat_rx_control_bytes, unsigned int *stat_rx_control_bytes,
unsigned int *stat_timer_reordering_timed_out, unsigned int *stat_timer_reordering_timed_out,
unsigned int *stat_timer_poll_retransmit_timed_out, unsigned int *stat_timer_poll_retransmit_timed_out,
unsigned int* stat_timer_status_prohibit_timed_out) unsigned int *stat_timer_status_prohibit_timed_out) {
{
*stat_tx_pdcp_sdu = rlc_pP->stat_tx_pdcp_sdu; *stat_tx_pdcp_sdu = rlc_pP->stat_tx_pdcp_sdu;
*stat_tx_pdcp_bytes = rlc_pP->stat_tx_pdcp_bytes; *stat_tx_pdcp_bytes = rlc_pP->stat_tx_pdcp_bytes;
*stat_tx_pdcp_sdu_discarded = rlc_pP->stat_tx_pdcp_sdu_discarded; *stat_tx_pdcp_sdu_discarded = rlc_pP->stat_tx_pdcp_sdu_discarded;
@@ -396,15 +362,13 @@ void rlc_am_stat_req (
*stat_timer_reordering_timed_out = rlc_pP->stat_timer_reordering_timed_out; *stat_timer_reordering_timed_out = rlc_pP->stat_timer_reordering_timed_out;
*stat_timer_poll_retransmit_timed_out = rlc_pP->stat_timer_poll_retransmit_timed_out; *stat_timer_poll_retransmit_timed_out = rlc_pP->stat_timer_poll_retransmit_timed_out;
*stat_timer_status_prohibit_timed_out = rlc_pP->stat_timer_status_prohibit_timed_out; *stat_timer_status_prohibit_timed_out = rlc_pP->stat_timer_status_prohibit_timed_out;
} }
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
void void
rlc_am_get_pdus ( rlc_am_get_pdus (
const protocol_ctxt_t *const ctxt_pP, const protocol_ctxt_t *const ctxt_pP,
rlc_am_entity_t *const rlc_pP rlc_am_entity_t *const rlc_pP
) ) {
{
//int display_flag = 0; //int display_flag = 0;
// 5.1.3.1 Transmit operations // 5.1.3.1 Transmit operations
// 5.1.3.1.1 // 5.1.3.1.1
@@ -412,10 +376,7 @@ rlc_am_get_pdus (
// The transmitting side of an AM RLC entity shall prioritize transmission of RLC control PDUs over RLC data PDUs. // The transmitting side of an AM RLC entity shall prioritize transmission of RLC control PDUs over RLC data PDUs.
// The transmitting side of an AM RLC entity shall prioritize retransmission of RLC data PDUs over transmission of new // The transmitting side of an AM RLC entity shall prioritize retransmission of RLC data PDUs over transmission of new
// AMD PDUs. // AMD PDUs.
switch (rlc_pP->protocol_state) { switch (rlc_pP->protocol_state) {
case RLC_NULL_STATE: case RLC_NULL_STATE:
break; break;
@@ -434,7 +395,6 @@ rlc_am_get_pdus (
// //
// When a STATUS PDU has been delivered to lower layer, the receiving side of an AM RLC entity shall: // When a STATUS PDU has been delivered to lower layer, the receiving side of an AM RLC entity shall:
// - start t-StatusProhibit. // - start t-StatusProhibit.
rlc_am_send_status_pdu(ctxt_pP, rlc_pP); rlc_am_send_status_pdu(ctxt_pP, rlc_pP);
mem_block_t *pdu = list_remove_head(&rlc_pP->control_pdu_list); mem_block_t *pdu = list_remove_head(&rlc_pP->control_pdu_list);
@@ -445,8 +405,7 @@ rlc_am_get_pdus (
rlc_am_start_timer_status_prohibit(ctxt_pP, rlc_pP); rlc_am_start_timer_status_prohibit(ctxt_pP, rlc_pP);
return; return;
} }
} } else {
else {
LOG_D(RLC, PROTOCOL_RLC_AM_CTXT_FMT" DELAYED SENT STATUS PDU (Available MAC Data %u)(T-PROHIBIT %u) (DELAY FLAG %u)\n", LOG_D(RLC, PROTOCOL_RLC_AM_CTXT_FMT" DELAYED SENT STATUS PDU (Available MAC Data %u)(T-PROHIBIT %u) (DELAY FLAG %u)\n",
PROTOCOL_RLC_AM_CTXT_ARGS(ctxt_pP,rlc_pP), PROTOCOL_RLC_AM_CTXT_ARGS(ctxt_pP,rlc_pP),
rlc_pP->nb_bytes_requested_by_mac,rlc_pP->t_status_prohibit.ms_time_out,(rlc_pP->status_requested & RLC_AM_STATUS_TRIGGERED_DELAYED)); rlc_pP->nb_bytes_requested_by_mac,rlc_pP->t_status_prohibit.ms_time_out,(rlc_pP->status_requested & RLC_AM_STATUS_TRIGGERED_DELAYED));
@@ -454,13 +413,11 @@ rlc_am_get_pdus (
// THEN TRY TO SEND RETRANS PDU // THEN TRY TO SEND RETRANS PDU
if ((rlc_pP->retrans_num_bytes_to_retransmit) && (rlc_pP->nb_bytes_requested_by_mac > 2)) { if ((rlc_pP->retrans_num_bytes_to_retransmit) && (rlc_pP->nb_bytes_requested_by_mac > 2)) {
/* Get 1 AM data PDU or PDU segment to retransmit */ /* Get 1 AM data PDU or PDU segment to retransmit */
mem_block_t *pdu_retx = rlc_am_get_pdu_to_retransmit(ctxt_pP, rlc_pP); mem_block_t *pdu_retx = rlc_am_get_pdu_to_retransmit(ctxt_pP, rlc_pP);
if (pdu_retx != NULL) { if (pdu_retx != NULL) {
list_add_tail_eurecom (pdu_retx, &rlc_pP->pdus_to_mac_layer); list_add_tail_eurecom (pdu_retx, &rlc_pP->pdus_to_mac_layer);
return; return;
} }
} }
@@ -477,7 +434,6 @@ rlc_am_get_pdus (
} }
} }
break; break;
default: default:
@@ -492,12 +448,10 @@ rlc_am_rx (
const protocol_ctxt_t *const ctxt_pP, const protocol_ctxt_t *const ctxt_pP,
void *const arg_pP, void *const arg_pP,
struct mac_data_ind data_indP struct mac_data_ind data_indP
) ) {
{
rlc_am_entity_t *rlc = (rlc_am_entity_t *) arg_pP; rlc_am_entity_t *rlc = (rlc_am_entity_t *) arg_pP;
switch (rlc->protocol_state) { switch (rlc->protocol_state) {
case RLC_NULL_STATE: case RLC_NULL_STATE:
LOG_I(RLC, PROTOCOL_RLC_AM_CTXT_FMT" ERROR MAC_DATA_IND IN RLC_NULL_STATE\n", PROTOCOL_RLC_AM_CTXT_ARGS(ctxt_pP, rlc)); LOG_I(RLC, PROTOCOL_RLC_AM_CTXT_FMT" ERROR MAC_DATA_IND IN RLC_NULL_STATE\n", PROTOCOL_RLC_AM_CTXT_ARGS(ctxt_pP, rlc));
list_free (&data_indP.data); list_free (&data_indP.data);
@@ -520,14 +474,12 @@ rlc_am_mac_status_indication (
void *const rlc_pP, void *const rlc_pP,
const uint16_t tb_sizeP, const uint16_t tb_sizeP,
struct mac_status_ind tx_statusP, struct mac_status_ind tx_statusP,
const eNB_flag_t enb_flagP) const eNB_flag_t enb_flagP) {
{
struct mac_status_resp status_resp; struct mac_status_resp status_resp;
uint16_t sdu_size = 0; uint16_t sdu_size = 0;
uint16_t sdu_remaining_size = 0; uint16_t sdu_remaining_size = 0;
int32_t diff_time=0; int32_t diff_time=0;
rlc_am_entity_t *rlc = (rlc_am_entity_t *) rlc_pP; rlc_am_entity_t *rlc = (rlc_am_entity_t *) rlc_pP;
status_resp.buffer_occupancy_in_bytes = 0; status_resp.buffer_occupancy_in_bytes = 0;
status_resp.buffer_occupancy_in_pdus = 0; status_resp.buffer_occupancy_in_pdus = 0;
status_resp.head_sdu_remaining_size_to_send = 0; status_resp.head_sdu_remaining_size_to_send = 0;
@@ -577,15 +529,11 @@ rlc_am_mac_status_indication (
status_resp.buffer_occupancy_in_bytes += (header_overhead + max_li_overhead); status_resp.buffer_occupancy_in_bytes += (header_overhead + max_li_overhead);
} }
if ((rlc->input_sdus[rlc->current_sdu_index].mem_block != NULL) && (status_resp.buffer_occupancy_in_bytes)) { if ((rlc->input_sdus[rlc->current_sdu_index].mem_block != NULL) && (status_resp.buffer_occupancy_in_bytes)) {
//status_resp.buffer_occupancy_in_bytes += ((rlc_am_entity_t *) rlc)->tx_header_min_length_in_bytes; //status_resp.buffer_occupancy_in_bytes += ((rlc_am_entity_t *) rlc)->tx_header_min_length_in_bytes;
status_resp.buffer_occupancy_in_pdus = rlc->nb_sdu; status_resp.buffer_occupancy_in_pdus = rlc->nb_sdu;
diff_time = ctxt_pP->frame - ((rlc_am_tx_sdu_management_t *) (rlc->input_sdus[rlc->current_sdu_index].mem_block->data))->sdu_creation_time; diff_time = ctxt_pP->frame - ((rlc_am_tx_sdu_management_t *) (rlc->input_sdus[rlc->current_sdu_index].mem_block->data))->sdu_creation_time;
status_resp.head_sdu_creation_time = (diff_time > 0 ) ? (uint32_t) diff_time : (uint32_t)(0xffffffff - diff_time + ctxt_pP->frame) ; status_resp.head_sdu_creation_time = (diff_time > 0 ) ? (uint32_t) diff_time : (uint32_t)(0xffffffff - diff_time + ctxt_pP->frame) ;
sdu_size = ((rlc_am_tx_sdu_management_t *) (rlc->input_sdus[rlc->current_sdu_index].mem_block->data))->sdu_size; sdu_size = ((rlc_am_tx_sdu_management_t *) (rlc->input_sdus[rlc->current_sdu_index].mem_block->data))->sdu_size;
sdu_remaining_size = ((rlc_am_tx_sdu_management_t *) (rlc->input_sdus[rlc->current_sdu_index].mem_block->data))->sdu_remaining_size; sdu_remaining_size = ((rlc_am_tx_sdu_management_t *) (rlc->input_sdus[rlc->current_sdu_index].mem_block->data))->sdu_remaining_size;
status_resp.head_sdu_remaining_size_to_send = sdu_remaining_size; status_resp.head_sdu_remaining_size_to_send = sdu_remaining_size;
@@ -595,7 +543,6 @@ rlc_am_mac_status_indication (
} else { } else {
status_resp.head_sdu_is_segmented = 1; status_resp.head_sdu_is_segmented = 1;
} }
} else { } else {
/* Not so many possibilities ... */ /* Not so many possibilities ... */
/* either buffer_occupancy_in_bytes = 0 and that's it */ /* either buffer_occupancy_in_bytes = 0 and that's it */
@@ -607,7 +554,8 @@ rlc_am_mac_status_indication (
status_resp.head_sdu_is_segmented = 1; status_resp.head_sdu_is_segmented = 1;
} }
} }
#if MESSAGE_CHART_GENERATOR_RLC_MAC
if (MESSAGE_CHART_GENERATOR) {
MSC_LOG_RX_MESSAGE( MSC_LOG_RX_MESSAGE(
(ctxt_pP->enb_flag == ENB_FLAG_YES) ? MSC_RLC_ENB:MSC_RLC_UE, (ctxt_pP->enb_flag == ENB_FLAG_YES) ? MSC_RLC_ENB:MSC_RLC_UE,
(ctxt_pP->enb_flag == ENB_FLAG_YES) ? MSC_MAC_ENB:MSC_MAC_UE, (ctxt_pP->enb_flag == ENB_FLAG_YES) ? MSC_MAC_ENB:MSC_MAC_UE,
@@ -627,26 +575,17 @@ rlc_am_mac_status_indication (
status_resp.buffer_occupancy_in_pdus,rlc->nb_sdu, status_resp.buffer_occupancy_in_pdus,rlc->nb_sdu,
(status_resp.head_sdu_is_segmented)?"sdu seg":"sdu not seg", (status_resp.head_sdu_is_segmented)?"sdu seg":"sdu not seg",
status_resp.head_sdu_remaining_size_to_send); status_resp.head_sdu_remaining_size_to_send);
#endif }
#if TRACE_RLC_AM_TX_STATUS
if (LOG_DEBUGFLAG(DEBUG_RLC)) {
if (tb_sizeP > 0) { if (tb_sizeP > 0) {
LOG_D(RLC, PROTOCOL_RLC_AM_CTXT_FMT" MAC_STATUS_INDICATION (DATA) %d bytes -> %d bytes\n", LOG_UI(RLC, PROTOCOL_RLC_AM_CTXT_FMT" MAC_STATUS_INDICATION (DATA) %d bytes -> %d bytes\n",
PROTOCOL_RLC_AM_CTXT_ARGS(ctxt_pP,rlc_pP), PROTOCOL_RLC_AM_CTXT_ARGS(ctxt_pP,rlc),
tb_sizeP, tb_sizeP,
status_resp.buffer_occupancy_in_bytes); status_resp.buffer_occupancy_in_bytes);
/*if ((tx_statusP.tx_status == MAC_TX_STATUS_SUCCESSFUL) && (tx_statusP.no_pdu)) {
msg ("[FRAME %5u][%s][RLC_AM][MOD %u/%u][RB %u] MAC_STATUS_INDICATION TX STATUS SUCCESSFUL %d PDUs\n",rlc->module_id,
rlc->rb_id, ctxt_pP->frame, tx_statusP.no_pdu);
} }
if ((tx_statusP.tx_status == MAC_TX_STATUS_UNSUCCESSFUL) && (tx_statusP.no_pdu)) {
msg ("[FRAME %5u][%s][RLC_AM][MOD %u/%u][RB %u] MAC_STATUS_INDICATION TX STATUS UNSUCCESSFUL %d PDUs\n",rlc->module_id, rlc->rb_id,
ctxt_pP->frame, tx_statusP.no_pdu);
}*/
} }
#endif
return status_resp; return status_resp;
} }
@@ -655,8 +594,7 @@ void
rlc_am_set_nb_bytes_requested_by_mac ( rlc_am_set_nb_bytes_requested_by_mac (
void *const rlc_pP, void *const rlc_pP,
const tb_size_t tb_sizeP const tb_size_t tb_sizeP
) ) {
{
((rlc_am_entity_t *) rlc_pP)->nb_bytes_requested_by_mac = tb_sizeP; ((rlc_am_entity_t *) rlc_pP)->nb_bytes_requested_by_mac = tb_sizeP;
} }
@@ -666,12 +604,10 @@ rlc_am_mac_data_request (
const protocol_ctxt_t *const ctxt_pP, const protocol_ctxt_t *const ctxt_pP,
void *const rlc_pP, void *const rlc_pP,
const eNB_flag_t enb_flagP const eNB_flag_t enb_flagP
) ) {
{
struct mac_data_req data_req; struct mac_data_req data_req;
rlc_am_entity_t *l_rlc_p = (rlc_am_entity_t *) rlc_pP; rlc_am_entity_t *l_rlc_p = (rlc_am_entity_t *) rlc_pP;
unsigned int nb_bytes_requested_by_mac = ((rlc_am_entity_t *) rlc_pP)->nb_bytes_requested_by_mac; unsigned int nb_bytes_requested_by_mac = ((rlc_am_entity_t *) rlc_pP)->nb_bytes_requested_by_mac;
#if TRACE_RLC_AM_PDU || MESSAGE_CHART_GENERATOR
rlc_am_pdu_info_t pdu_info; rlc_am_pdu_info_t pdu_info;
rlc_am_pdu_sn_10_t *rlc_am_pdu_sn_10_p; rlc_am_pdu_sn_10_t *rlc_am_pdu_sn_10_p;
mem_block_t *tb_p; mem_block_t *tb_p;
@@ -679,9 +615,6 @@ rlc_am_mac_data_request (
int num_nack; int num_nack;
char message_string[9000]; char message_string[9000];
size_t message_string_size = 0; size_t message_string_size = 0;
# if ENABLE_ITTI
MessageDef *msg_p;
# endif
int octet_index, index; int octet_index, index;
/* for no gcc warnings */ /* for no gcc warnings */
(void)num_nack; (void)num_nack;
@@ -689,8 +622,6 @@ rlc_am_mac_data_request (
(void)message_string_size; (void)message_string_size;
(void)octet_index; (void)octet_index;
(void)index; (void)index;
#endif
list_init (&data_req.data, NULL); list_init (&data_req.data, NULL);
rlc_am_get_pdus (ctxt_pP, l_rlc_p); rlc_am_get_pdus (ctxt_pP, l_rlc_p);
list_add_list (&l_rlc_p->pdus_to_mac_layer, &data_req.data); list_add_list (&l_rlc_p->pdus_to_mac_layer, &data_req.data);
@@ -707,22 +638,19 @@ rlc_am_mac_data_request (
// redundant in UE MAC Tx processing and not used in eNB ... // redundant in UE MAC Tx processing and not used in eNB ...
data_req.buffer_occupancy_in_bytes = rlc_am_get_buffer_occupancy_in_bytes(ctxt_pP, l_rlc_p); data_req.buffer_occupancy_in_bytes = rlc_am_get_buffer_occupancy_in_bytes(ctxt_pP, l_rlc_p);
} }
data_req.rlc_info.rlc_protocol_state = l_rlc_p->protocol_state; data_req.rlc_info.rlc_protocol_state = l_rlc_p->protocol_state;
#if TRACE_RLC_AM_PDU || MESSAGE_CHART_GENERATOR if ( (MESSAGE_CHART_GENERATOR || LOG_DEBUGFLAG(DEBUG_RLC))&& data_req.data.nb_elements > 0) {
if (data_req.data.nb_elements > 0) {
tb_p = data_req.data.head; tb_p = data_req.data.head;
while (tb_p != NULL) { while (tb_p != NULL) {
rlc_am_pdu_sn_10_p = (rlc_am_pdu_sn_10_t *)((struct mac_tb_req *) (tb_p->data))->data_ptr; rlc_am_pdu_sn_10_p = (rlc_am_pdu_sn_10_t *)((struct mac_tb_req *) (tb_p->data))->data_ptr;
tb_size_in_bytes = ((struct mac_tb_req *) (tb_p->data))->tb_size; tb_size_in_bytes = ((struct mac_tb_req *) (tb_p->data))->tb_size;
if ((((struct mac_tb_req *) (tb_p->data))->data_ptr[0] & RLC_DC_MASK) == RLC_DC_DATA_PDU ) { if ((((struct mac_tb_req *) (tb_p->data))->data_ptr[0] & RLC_DC_MASK) == RLC_DC_DATA_PDU ) {
if (rlc_am_get_data_pdu_infos(ctxt_pP,l_rlc_p,rlc_am_pdu_sn_10_p, tb_size_in_bytes, &pdu_info) >= 0) { if (rlc_am_get_data_pdu_infos(ctxt_pP,l_rlc_p,rlc_am_pdu_sn_10_p, tb_size_in_bytes, &pdu_info) >= 0) {
#if MESSAGE_CHART_GENERATOR if (MESSAGE_CHART_GENERATOR) {
message_string_size = 0; message_string_size = 0;
message_string_size += sprintf(&message_string[message_string_size], message_string_size += sprintf(&message_string[message_string_size],
MSC_AS_TIME_FMT" "PROTOCOL_RLC_AM_MSC_FMT" DATA SN %u size %u RF %u P %u FI %u", MSC_AS_TIME_FMT" "PROTOCOL_RLC_AM_MSC_FMT" DATA SN %u size %u RF %u P %u FI %u",
@@ -753,9 +681,9 @@ rlc_am_mac_data_request (
(char *)rlc_am_pdu_sn_10_p, (char *)rlc_am_pdu_sn_10_p,
tb_size_in_bytes, tb_size_in_bytes,
message_string); message_string);
}
#endif if ( LOG_DEBUGFLAG(DEBUG_RLC)) {
# if ENABLE_ITTI
message_string_size = 0; message_string_size = 0;
message_string_size += sprintf(&message_string[message_string_size], "Bearer : %u\n", l_rlc_p->rb_id); message_string_size += sprintf(&message_string[message_string_size], "Bearer : %u\n", l_rlc_p->rb_id);
message_string_size += sprintf(&message_string[message_string_size], "PDU size : %u\n", tb_size_in_bytes); message_string_size += sprintf(&message_string[message_string_size], "PDU size : %u\n", tb_size_in_bytes);
@@ -819,22 +747,14 @@ rlc_am_mac_data_request (
message_string_size += sprintf(&message_string[message_string_size], " "); message_string_size += sprintf(&message_string[message_string_size], " ");
} }
message_string_size += sprintf(&message_string[message_string_size], " |\n"); LOG_UI(RLC,"%s\n",message_string);
} /* LOG_DEBUGFLAG(DEBUG_RLC) */
msg_p = itti_alloc_new_message_sized (ctxt_pP->enb_flag > 0 ? TASK_RLC_ENB:TASK_RLC_UE , RLC_AM_DATA_PDU_REQ, message_string_size + sizeof (IttiMsgText));
msg_p->ittiMsg.rlc_am_data_pdu_req.size = message_string_size;
memcpy(&msg_p->ittiMsg.rlc_am_data_pdu_req.text, message_string, message_string_size);
itti_send_msg_to_task(TASK_UNKNOWN, ctxt_pP->instance, msg_p);
# else
rlc_am_display_data_pdu_infos(ctxt_pP, l_rlc_p, &pdu_info);
# endif
} }
} else { } else {
if (rlc_am_get_control_pdu_infos(rlc_am_pdu_sn_10_p, &tb_size_in_bytes, &l_rlc_p->control_pdu_info) >= 0) { if (rlc_am_get_control_pdu_infos(rlc_am_pdu_sn_10_p, &tb_size_in_bytes, &l_rlc_p->control_pdu_info) >= 0) {
tb_size_in_bytes = ((struct mac_tb_req *) (tb_p->data))->tb_size; //tb_size_in_bytes modified by rlc_am_get_control_pdu_infos! tb_size_in_bytes = ((struct mac_tb_req *) (tb_p->data))->tb_size; //tb_size_in_bytes modified by rlc_am_get_control_pdu_infos!
#if MESSAGE_CHART_GENERATOR
if (MESSAGE_CHART_GENERATOR ) {
message_string_size = 0; message_string_size = 0;
message_string_size += sprintf(&message_string[message_string_size], message_string_size += sprintf(&message_string[message_string_size],
MSC_AS_TIME_FMT" "PROTOCOL_RLC_AM_MSC_FMT" STATUS ACK_SN %u", MSC_AS_TIME_FMT" "PROTOCOL_RLC_AM_MSC_FMT" STATUS ACK_SN %u",
@@ -848,7 +768,6 @@ rlc_am_mac_data_request (
l_rlc_p->control_pdu_info.nack_list[num_nack].nack_sn, l_rlc_p->control_pdu_info.nack_list[num_nack].nack_sn,
l_rlc_p->control_pdu_info.nack_list[num_nack].so_start, l_rlc_p->control_pdu_info.nack_list[num_nack].so_start,
l_rlc_p->control_pdu_info.nack_list[num_nack].so_end); l_rlc_p->control_pdu_info.nack_list[num_nack].so_end);
} else { } else {
message_string_size += sprintf(&message_string[message_string_size], " NACK SN %u", message_string_size += sprintf(&message_string[message_string_size], " NACK SN %u",
l_rlc_p->control_pdu_info.nack_list[num_nack].nack_sn); l_rlc_p->control_pdu_info.nack_list[num_nack].nack_sn);
@@ -861,9 +780,9 @@ rlc_am_mac_data_request (
(char *)rlc_am_pdu_sn_10_p, (char *)rlc_am_pdu_sn_10_p,
tb_size_in_bytes, tb_size_in_bytes,
message_string); message_string);
}
#endif if ( LOG_DEBUGFLAG(DEBUG_RLC)) {
# if ENABLE_ITTI
message_string_size = 0; message_string_size = 0;
message_string_size += sprintf(&message_string[message_string_size], "Bearer : %u\n", l_rlc_p->rb_id); message_string_size += sprintf(&message_string[message_string_size], "Bearer : %u\n", l_rlc_p->rb_id);
message_string_size += sprintf(&message_string[message_string_size], "PDU size : %u\n", tb_size_in_bytes); message_string_size += sprintf(&message_string[message_string_size], "PDU size : %u\n", tb_size_in_bytes);
@@ -885,21 +804,15 @@ rlc_am_mac_data_request (
} }
} }
msg_p = itti_alloc_new_message_sized (ctxt_pP->enb_flag > 0 ? TASK_RLC_ENB:TASK_RLC_UE , RLC_AM_STATUS_PDU_REQ, message_string_size + sizeof (IttiMsgText)); LOG_UI(RLC,"%s\n",message_string);
msg_p->ittiMsg.rlc_am_status_pdu_req.size = message_string_size; } /* LOG_DEBUGFLAG(DEBUG_RLC) */
memcpy(&msg_p->ittiMsg.rlc_am_status_pdu_req.text, message_string, message_string_size);
itti_send_msg_to_task(TASK_UNKNOWN, ctxt_pP->instance, msg_p);
# endif
} }
} }
tb_p = tb_p->next; tb_p = tb_p->next;
} } /* while */
} } /* MESSAGE_CHART_GENERATOR && data_req.data.nb_elements > 0 */
#endif
return data_req; return data_req;
} }
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
@@ -908,13 +821,11 @@ rlc_am_mac_data_indication (
const protocol_ctxt_t *const ctxt_pP, const protocol_ctxt_t *const ctxt_pP,
void *const rlc_pP, void *const rlc_pP,
struct mac_data_ind data_indP struct mac_data_ind data_indP
) ) {
{
rlc_am_entity_t *l_rlc_p = (rlc_am_entity_t *) rlc_pP; rlc_am_entity_t *l_rlc_p = (rlc_am_entity_t *) rlc_pP;
/*rlc_am_control_pdu_info_t control_pdu_info; /*rlc_am_control_pdu_info_t control_pdu_info;
int num_li; int num_li;
int16_t tb_size;*/ int16_t tb_size;*/
#if TRACE_RLC_AM_PDU || MESSAGE_CHART_GENERATOR
rlc_am_pdu_info_t pdu_info; rlc_am_pdu_info_t pdu_info;
rlc_am_pdu_sn_10_t *rlc_am_pdu_sn_10_p; rlc_am_pdu_sn_10_t *rlc_am_pdu_sn_10_p;
mem_block_t *tb_p; mem_block_t *tb_p;
@@ -922,9 +833,6 @@ rlc_am_mac_data_indication (
int num_nack; int num_nack;
char message_string[7000]; char message_string[7000];
size_t message_string_size = 0; size_t message_string_size = 0;
# if ENABLE_ITTI
MessageDef *msg_p;
# endif
int octet_index, index; int octet_index, index;
/* for no gcc warnings */ /* for no gcc warnings */
(void)num_nack; (void)num_nack;
@@ -932,24 +840,19 @@ rlc_am_mac_data_indication (
(void)message_string_size; (void)message_string_size;
(void)octet_index; (void)octet_index;
(void)index; (void)index;
#endif
(void)l_rlc_p; /* avoid gcc warning "unused variable" */ (void)l_rlc_p; /* avoid gcc warning "unused variable" */
#if TRACE_RLC_AM_PDU || MESSAGE_CHART_GENERATOR if ( LOG_DEBUGFLAG(DEBUG_RLC) || MESSAGE_CHART_GENERATOR ) {
if (data_indP.data.nb_elements > 0) { if (data_indP.data.nb_elements > 0) {
tb_p = data_indP.data.head; tb_p = data_indP.data.head;
while (tb_p != NULL) { while (tb_p != NULL) {
rlc_am_pdu_sn_10_p = (rlc_am_pdu_sn_10_t *)((struct mac_tb_ind *) (tb_p->data))->data_ptr; rlc_am_pdu_sn_10_p = (rlc_am_pdu_sn_10_t *)((struct mac_tb_ind *) (tb_p->data))->data_ptr;
tb_size_in_bytes = ((struct mac_tb_ind *) (tb_p->data))->size; tb_size_in_bytes = ((struct mac_tb_ind *) (tb_p->data))->size;
if ((((struct mac_tb_ind *) (tb_p->data))->data_ptr[0] & RLC_DC_MASK) == RLC_DC_DATA_PDU ) { if ((((struct mac_tb_ind *) (tb_p->data))->data_ptr[0] & RLC_DC_MASK) == RLC_DC_DATA_PDU ) {
if (rlc_am_get_data_pdu_infos(ctxt_pP,l_rlc_p,rlc_am_pdu_sn_10_p, tb_size_in_bytes, &pdu_info) >= 0) { if (rlc_am_get_data_pdu_infos(ctxt_pP,l_rlc_p,rlc_am_pdu_sn_10_p, tb_size_in_bytes, &pdu_info) >= 0) {
#if MESSAGE_CHART_GENERATOR if (MESSAGE_CHART_GENERATOR) {
message_string_size = 0; message_string_size = 0;
message_string_size += sprintf(&message_string[message_string_size], message_string_size += sprintf(&message_string[message_string_size],
MSC_AS_TIME_FMT" "PROTOCOL_RLC_AM_MSC_FMT" DATA SN %u size %u RF %u P %u FI %u", MSC_AS_TIME_FMT" "PROTOCOL_RLC_AM_MSC_FMT" DATA SN %u size %u RF %u P %u FI %u",
@@ -980,10 +883,9 @@ rlc_am_mac_data_indication (
(char *)rlc_am_pdu_sn_10_p, (char *)rlc_am_pdu_sn_10_p,
tb_size_in_bytes, tb_size_in_bytes,
message_string); message_string);
}
#endif if ( LOG_DEBUGFLAG(DEBUG_RLC)) {
# if ENABLE_ITTI && TRACE_RLC_AM_PDU
message_string_size += sprintf(&message_string[message_string_size], "Bearer : %u\n", l_rlc_p->rb_id); message_string_size += sprintf(&message_string[message_string_size], "Bearer : %u\n", l_rlc_p->rb_id);
message_string_size += sprintf(&message_string[message_string_size], "PDU size : %u\n", tb_size_in_bytes); message_string_size += sprintf(&message_string[message_string_size], "PDU size : %u\n", tb_size_in_bytes);
message_string_size += sprintf(&message_string[message_string_size], "Header size : %u\n", pdu_info.header_size); message_string_size += sprintf(&message_string[message_string_size], "Header size : %u\n", pdu_info.header_size);
@@ -1046,21 +948,12 @@ rlc_am_mac_data_indication (
message_string_size += sprintf(&message_string[message_string_size], " "); message_string_size += sprintf(&message_string[message_string_size], " ");
} }
message_string_size += sprintf(&message_string[message_string_size], " |\n"); LOG_UI(RLC,"%s\n",message_string);
} /* LOG_DEBUGFLAG */
msg_p = itti_alloc_new_message_sized (ctxt_pP->enb_flag > 0 ? TASK_RLC_ENB:TASK_RLC_UE , RLC_AM_DATA_PDU_IND, message_string_size + sizeof (IttiMsgText));
msg_p->ittiMsg.rlc_am_data_pdu_ind.size = message_string_size;
memcpy(&msg_p->ittiMsg.rlc_am_data_pdu_ind.text, message_string, message_string_size);
itti_send_msg_to_task(TASK_UNKNOWN, ctxt_pP->instance, msg_p);
# else
rlc_am_display_data_pdu_infos(ctxt_pP, l_rlc_p, &pdu_info);
# endif
} }
} else { } else {
if (rlc_am_get_control_pdu_infos(rlc_am_pdu_sn_10_p, &tb_size_in_bytes, &l_rlc_p->control_pdu_info) >= 0) { if (rlc_am_get_control_pdu_infos(rlc_am_pdu_sn_10_p, &tb_size_in_bytes, &l_rlc_p->control_pdu_info) >= 0) {
#if MESSAGE_CHART_GENERATOR if (MESSAGE_CHART_GENERATOR) {
message_string_size = 0; message_string_size = 0;
message_string_size += sprintf(&message_string[message_string_size], message_string_size += sprintf(&message_string[message_string_size],
MSC_AS_TIME_FMT" "PROTOCOL_RLC_AM_MSC_FMT" STATUS size ACK_SN %u", MSC_AS_TIME_FMT" "PROTOCOL_RLC_AM_MSC_FMT" STATUS size ACK_SN %u",
@@ -1074,7 +967,6 @@ rlc_am_mac_data_indication (
l_rlc_p->control_pdu_info.nack_list[num_nack].nack_sn, l_rlc_p->control_pdu_info.nack_list[num_nack].nack_sn,
l_rlc_p->control_pdu_info.nack_list[num_nack].so_start, l_rlc_p->control_pdu_info.nack_list[num_nack].so_start,
l_rlc_p->control_pdu_info.nack_list[num_nack].so_end); l_rlc_p->control_pdu_info.nack_list[num_nack].so_end);
} else { } else {
message_string_size += sprintf(&message_string[message_string_size], " NACK SN %u", message_string_size += sprintf(&message_string[message_string_size], " NACK SN %u",
l_rlc_p->control_pdu_info.nack_list[num_nack].nack_sn); l_rlc_p->control_pdu_info.nack_list[num_nack].nack_sn);
@@ -1087,10 +979,9 @@ rlc_am_mac_data_indication (
(char *)rlc_am_pdu_sn_10_p, (char *)rlc_am_pdu_sn_10_p,
tb_size_in_bytes, tb_size_in_bytes,
message_string); message_string);
}
#endif if ( LOG_DEBUGFLAG(DEBUG_RLC)) {
# if ENABLE_ITTI && TRACE_RLC_AM_PDU
message_string_size = 0; message_string_size = 0;
message_string_size += sprintf(&message_string[message_string_size], "Bearer : %u\n", l_rlc_p->rb_id); message_string_size += sprintf(&message_string[message_string_size], "Bearer : %u\n", l_rlc_p->rb_id);
message_string_size += sprintf(&message_string[message_string_size], "PDU size : %u\n", ((struct mac_tb_ind *) (tb_p->data))->size); message_string_size += sprintf(&message_string[message_string_size], "PDU size : %u\n", ((struct mac_tb_ind *) (tb_p->data))->size);
@@ -1112,21 +1003,16 @@ rlc_am_mac_data_indication (
} }
} }
msg_p = itti_alloc_new_message_sized (ctxt_pP->enb_flag > 0 ? TASK_RLC_ENB:TASK_RLC_UE , RLC_AM_STATUS_PDU_IND, message_string_size + sizeof (IttiMsgText)); LOG_UI(RLC, "%s\n",message_string);
msg_p->ittiMsg.rlc_am_status_pdu_ind.size = message_string_size; }
memcpy(&msg_p->ittiMsg.rlc_am_status_pdu_ind.text, message_string, message_string_size);
itti_send_msg_to_task(TASK_UNKNOWN, ctxt_pP->instance, msg_p);
# endif
} }
} }
tb_p = tb_p->next; tb_p = tb_p->next;
} }
} }
} /* LOG_DEBUGFLAG(RLC) || MESSAGE_TRACE_GENERATOR) */
#endif
rlc_am_rx (ctxt_pP, rlc_pP, data_indP); rlc_am_rx (ctxt_pP, rlc_pP, data_indP);
} }
@@ -1135,35 +1021,24 @@ void
rlc_am_data_req ( rlc_am_data_req (
const protocol_ctxt_t *const ctxt_pP, const protocol_ctxt_t *const ctxt_pP,
void *const rlc_pP, void *const rlc_pP,
mem_block_t * const sdu_pP) mem_block_t *const sdu_pP) {
{
rlc_am_entity_t *l_rlc_p = (rlc_am_entity_t *) rlc_pP; rlc_am_entity_t *l_rlc_p = (rlc_am_entity_t *) rlc_pP;
uint32_t mui; uint32_t mui;
uint16_t data_offset; uint16_t data_offset;
uint16_t data_size; uint16_t data_size;
#if TRACE_RLC_AM_PDU
char message_string[7000]; char message_string[7000];
size_t message_string_size = 0; size_t message_string_size = 0;
#if ENABLE_ITTI
MessageDef *msg_p;
#endif
int octet_index, index; int octet_index, index;
#endif
RLC_AM_MUTEX_LOCK(&l_rlc_p->lock_input_sdus, ctxt_pP, l_rlc_p); RLC_AM_MUTEX_LOCK(&l_rlc_p->lock_input_sdus, ctxt_pP, l_rlc_p);
if ((l_rlc_p->input_sdus[l_rlc_p->next_sdu_index].mem_block == NULL) && if ((l_rlc_p->input_sdus[l_rlc_p->next_sdu_index].mem_block == NULL) &&
(l_rlc_p->input_sdus[l_rlc_p->next_sdu_index].flags.segmented == 0) && (l_rlc_p->input_sdus[l_rlc_p->next_sdu_index].flags.segmented == 0) &&
(((l_rlc_p->next_sdu_index + 1) % RLC_AM_SDU_CONTROL_BUFFER_SIZE) != l_rlc_p->current_sdu_index)) { (((l_rlc_p->next_sdu_index + 1) % RLC_AM_SDU_CONTROL_BUFFER_SIZE) != l_rlc_p->current_sdu_index)) {
memset(&l_rlc_p->input_sdus[l_rlc_p->next_sdu_index], 0, sizeof(rlc_am_tx_sdu_management_t)); memset(&l_rlc_p->input_sdus[l_rlc_p->next_sdu_index], 0, sizeof(rlc_am_tx_sdu_management_t));
l_rlc_p->input_sdus[l_rlc_p->next_sdu_index].mem_block = sdu_pP; l_rlc_p->input_sdus[l_rlc_p->next_sdu_index].mem_block = sdu_pP;
mui = ((struct rlc_am_data_req *) (sdu_pP->data))->mui; mui = ((struct rlc_am_data_req *) (sdu_pP->data))->mui;
data_offset = ((struct rlc_am_data_req *) (sdu_pP->data))->data_offset; data_offset = ((struct rlc_am_data_req *) (sdu_pP->data))->data_offset;
data_size = ((struct rlc_am_data_req *) (sdu_pP->data))->data_size; data_size = ((struct rlc_am_data_req *) (sdu_pP->data))->data_size;
MSC_LOG_RX_MESSAGE( MSC_LOG_RX_MESSAGE(
(ctxt_pP->enb_flag == ENB_FLAG_YES) ? MSC_RLC_ENB:MSC_RLC_UE, (ctxt_pP->enb_flag == ENB_FLAG_YES) ? MSC_RLC_ENB:MSC_RLC_UE,
(ctxt_pP->enb_flag == ENB_FLAG_YES) ? MSC_PDCP_ENB:MSC_PDCP_UE, (ctxt_pP->enb_flag == ENB_FLAG_YES) ? MSC_PDCP_ENB:MSC_PDCP_UE,
@@ -1175,13 +1050,11 @@ rlc_am_data_req (
data_size, data_size,
mui); mui);
if (LOG_DEBUGFLAG(DEBUG_RLC)) {
#if TRACE_RLC_AM_PDU
message_string_size += sprintf(&message_string[message_string_size], "Bearer : %u\n", l_rlc_p->rb_id); message_string_size += sprintf(&message_string[message_string_size], "Bearer : %u\n", l_rlc_p->rb_id);
message_string_size += sprintf(&message_string[message_string_size], "SDU size : %u\n", data_size); message_string_size += sprintf(&message_string[message_string_size], "SDU size : %u\n", data_size);
message_string_size += sprintf(&message_string[message_string_size], "MUI : %u\n", mui); message_string_size += sprintf(&message_string[message_string_size], "MUI : %u\n", mui);
message_string_size += sprintf(&message_string[message_string_size], "CONF : %u\n", ((struct rlc_am_data_req *) (sdu_pP->data))->conf); message_string_size += sprintf(&message_string[message_string_size], "CONF : %u\n", ((struct rlc_am_data_req *) (sdu_pP->data))->conf);
message_string_size += sprintf(&message_string[message_string_size], "\nPayload : \n"); message_string_size += sprintf(&message_string[message_string_size], "\nPayload : \n");
message_string_size += sprintf(&message_string[message_string_size], "------+-------------------------------------------------|\n"); message_string_size += sprintf(&message_string[message_string_size], "------+-------------------------------------------------|\n");
message_string_size += sprintf(&message_string[message_string_size], " | 0 1 2 3 4 5 6 7 8 9 a b c d e f |\n"); message_string_size += sprintf(&message_string[message_string_size], " | 0 1 2 3 4 5 6 7 8 9 a b c d e f |\n");
@@ -1213,29 +1086,16 @@ rlc_am_data_req (
} }
message_string_size += sprintf(&message_string[message_string_size], " |\n"); message_string_size += sprintf(&message_string[message_string_size], " |\n");
LOG_UI(RLC, "%s\n", message_string);
# if ENABLE_ITTI } /* LOG_DEBUGFLAG(RLC) */
msg_p = itti_alloc_new_message_sized (ctxt_pP->enb_flag > 0 ? TASK_RLC_ENB:TASK_RLC_UE , RLC_AM_SDU_REQ, message_string_size + sizeof (IttiMsgText));
msg_p->ittiMsg.rlc_am_sdu_req.size = message_string_size;
memcpy(&msg_p->ittiMsg.rlc_am_sdu_req.text, message_string, message_string_size);
itti_send_msg_to_task(TASK_UNKNOWN, ctxt_pP->instance, msg_p);
# else
LOG_T(RLC, "%s", message_string);
# endif
#endif
l_rlc_p->stat_tx_pdcp_sdu += 1; l_rlc_p->stat_tx_pdcp_sdu += 1;
l_rlc_p->stat_tx_pdcp_bytes += data_size; l_rlc_p->stat_tx_pdcp_bytes += data_size;
l_rlc_p->input_sdus[l_rlc_p->next_sdu_index].mui = mui; l_rlc_p->input_sdus[l_rlc_p->next_sdu_index].mui = mui;
l_rlc_p->input_sdus[l_rlc_p->next_sdu_index].sdu_size = data_size; l_rlc_p->input_sdus[l_rlc_p->next_sdu_index].sdu_size = data_size;
l_rlc_p->sdu_buffer_occupancy += data_size; l_rlc_p->sdu_buffer_occupancy += data_size;
l_rlc_p->nb_sdu += 1; l_rlc_p->nb_sdu += 1;
l_rlc_p->nb_sdu_no_segmented += 1; l_rlc_p->nb_sdu_no_segmented += 1;
l_rlc_p->input_sdus[l_rlc_p->next_sdu_index].first_byte = (uint8_t *)(&sdu_pP->data[data_offset]); l_rlc_p->input_sdus[l_rlc_p->next_sdu_index].first_byte = (uint8_t *)(&sdu_pP->data[data_offset]);
l_rlc_p->input_sdus[l_rlc_p->next_sdu_index].sdu_remaining_size = l_rlc_p->input_sdus[l_rlc_p->next_sdu_index].sdu_size; l_rlc_p->input_sdus[l_rlc_p->next_sdu_index].sdu_remaining_size = l_rlc_p->input_sdus[l_rlc_p->next_sdu_index].sdu_size;
l_rlc_p->input_sdus[l_rlc_p->next_sdu_index].sdu_segmented_size = 0; l_rlc_p->input_sdus[l_rlc_p->next_sdu_index].sdu_segmented_size = 0;
@@ -1250,8 +1110,8 @@ rlc_am_data_req (
l_rlc_p->input_sdus[l_rlc_p->next_sdu_index].flags.no_new_sdu_segmented_in_last_pdu = 0; l_rlc_p->input_sdus[l_rlc_p->next_sdu_index].flags.no_new_sdu_segmented_in_last_pdu = 0;
//l_rlc_p->input_sdus[l_rlc_p->next_sdu_index].li_index_for_discard = -1; //l_rlc_p->input_sdus[l_rlc_p->next_sdu_index].li_index_for_discard = -1;
l_rlc_p->next_sdu_index = (l_rlc_p->next_sdu_index + 1) % RLC_AM_SDU_CONTROL_BUFFER_SIZE; l_rlc_p->next_sdu_index = (l_rlc_p->next_sdu_index + 1) % RLC_AM_SDU_CONTROL_BUFFER_SIZE;
if (l_rlc_p->channel_id <3)
{ if (l_rlc_p->channel_id <3) {
LOG_I(RLC, PROTOCOL_RLC_AM_CTXT_FMT" RLC_AM_DATA_REQ size %d Bytes, NB SDU %d current_sdu_index=%d next_sdu_index=%d conf %d mui %d vtA %d vtS %d\n", LOG_I(RLC, PROTOCOL_RLC_AM_CTXT_FMT" RLC_AM_DATA_REQ size %d Bytes, NB SDU %d current_sdu_index=%d next_sdu_index=%d conf %d mui %d vtA %d vtS %d\n",
PROTOCOL_RLC_AM_CTXT_ARGS(ctxt_pP,l_rlc_p), PROTOCOL_RLC_AM_CTXT_ARGS(ctxt_pP,l_rlc_p),
data_size, data_size,
@@ -1264,7 +1124,7 @@ rlc_am_data_req (
l_rlc_p->vt_s); l_rlc_p->vt_s);
} }
} else { } else {
#if MESSAGE_CHART_GENERATOR if( MESSAGE_CHART_GENERATOR) {
mui = ((struct rlc_am_data_req *) (sdu_pP->data))->mui; mui = ((struct rlc_am_data_req *) (sdu_pP->data))->mui;
data_offset = ((struct rlc_am_data_req *) (sdu_pP->data))->data_offset; data_offset = ((struct rlc_am_data_req *) (sdu_pP->data))->data_offset;
data_size = ((struct rlc_am_data_req *) (sdu_pP->data))->data_size; data_size = ((struct rlc_am_data_req *) (sdu_pP->data))->data_size;
@@ -1278,7 +1138,8 @@ rlc_am_data_req (
PROTOCOL_RLC_AM_MSC_ARGS(ctxt_pP, l_rlc_p), PROTOCOL_RLC_AM_MSC_ARGS(ctxt_pP, l_rlc_p),
data_size, data_size,
mui); mui);
#endif }
LOG_W(RLC, PROTOCOL_RLC_AM_CTXT_FMT" RLC_AM_DATA_REQ BUFFER FULL, NB SDU %d current_sdu_index=%d next_sdu_index=%d size_input_sdus_buffer=%d vtA=%d vtS=%d\n", LOG_W(RLC, PROTOCOL_RLC_AM_CTXT_FMT" RLC_AM_DATA_REQ BUFFER FULL, NB SDU %d current_sdu_index=%d next_sdu_index=%d size_input_sdus_buffer=%d vtA=%d vtS=%d\n",
PROTOCOL_RLC_AM_CTXT_ARGS(ctxt_pP,l_rlc_p), PROTOCOL_RLC_AM_CTXT_ARGS(ctxt_pP,l_rlc_p),
l_rlc_p->nb_sdu, l_rlc_p->nb_sdu,
openair2/LAYER2/RLC/AM_v9.3.0/rlc_am_reassembly.c
+16 -43
View File
@@ -23,9 +23,7 @@
#define RLC_AM_REASSEMBLY_C 1 #define RLC_AM_REASSEMBLY_C 1
#include "platform_types.h" #include "platform_types.h"
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
#if ENABLE_ITTI
# include "intertask_interface.h"
#endif
#include "assertions.h" #include "assertions.h"
#include "rlc.h" #include "rlc.h"
#include "rlc_am.h" #include "rlc_am.h"
@@ -38,8 +36,7 @@
inline void inline void
rlc_am_clear_rx_sdu ( rlc_am_clear_rx_sdu (
const protocol_ctxt_t *const ctxt_pP, const protocol_ctxt_t *const ctxt_pP,
rlc_am_entity_t * const rlc_pP) rlc_am_entity_t *const rlc_pP) {
{
rlc_pP->output_sdu_size_to_write = 0; rlc_pP->output_sdu_size_to_write = 0;
} }
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
@@ -48,8 +45,7 @@ rlc_am_reassembly (
const protocol_ctxt_t *const ctxt_pP, const protocol_ctxt_t *const ctxt_pP,
rlc_am_entity_t *const rlc_pP, rlc_am_entity_t *const rlc_pP,
uint8_t *src_pP, uint8_t *src_pP,
const int32_t lengthP) const int32_t lengthP) {
{
LOG_D(RLC, PROTOCOL_RLC_AM_CTXT_FMT"[REASSEMBLY PAYLOAD] reassembly() %d bytes\n", LOG_D(RLC, PROTOCOL_RLC_AM_CTXT_FMT"[REASSEMBLY PAYLOAD] reassembly() %d bytes\n",
PROTOCOL_RLC_AM_CTXT_ARGS(ctxt_pP,rlc_pP), PROTOCOL_RLC_AM_CTXT_ARGS(ctxt_pP,rlc_pP),
lengthP); lengthP);
@@ -57,6 +53,7 @@ rlc_am_reassembly (
if (rlc_pP->output_sdu_in_construction == NULL) { if (rlc_pP->output_sdu_in_construction == NULL) {
rlc_pP->output_sdu_in_construction = get_free_mem_block (RLC_SDU_MAX_SIZE, __func__); rlc_pP->output_sdu_in_construction = get_free_mem_block (RLC_SDU_MAX_SIZE, __func__);
rlc_pP->output_sdu_size_to_write = 0; rlc_pP->output_sdu_size_to_write = 0;
//assert(rlc_pP->output_sdu_in_construction != NULL); //assert(rlc_pP->output_sdu_in_construction != NULL);
if(rlc_pP->output_sdu_in_construction == NULL) { if(rlc_pP->output_sdu_in_construction == NULL) {
LOG_E(RLC, PROTOCOL_RLC_AM_CTXT_FMT"[REASSEMBLY PAYLOAD] output_sdu_in_construction is NULL\n", LOG_E(RLC, PROTOCOL_RLC_AM_CTXT_FMT"[REASSEMBLY PAYLOAD] output_sdu_in_construction is NULL\n",
@@ -66,7 +63,6 @@ rlc_am_reassembly (
} }
if (rlc_pP->output_sdu_in_construction != NULL) { if (rlc_pP->output_sdu_in_construction != NULL) {
// check if no overflow in size // check if no overflow in size
if ((rlc_pP->output_sdu_size_to_write + lengthP) <= RLC_SDU_MAX_SIZE) { if ((rlc_pP->output_sdu_size_to_write + lengthP) <= RLC_SDU_MAX_SIZE) {
memcpy (&rlc_pP->output_sdu_in_construction->data[rlc_pP->output_sdu_size_to_write], src_pP, lengthP); memcpy (&rlc_pP->output_sdu_in_construction->data[rlc_pP->output_sdu_size_to_write], src_pP, lengthP);
@@ -94,17 +90,7 @@ rlc_am_reassembly (
void void
rlc_am_send_sdu ( rlc_am_send_sdu (
const protocol_ctxt_t *const ctxt_pP, const protocol_ctxt_t *const ctxt_pP,
rlc_am_entity_t * const rlc_pP) rlc_am_entity_t *const rlc_pP) {
{
# if TRACE_RLC_AM_PDU
char message_string[7000];
size_t message_string_size = 0;
#if ENABLE_ITTI
MessageDef *msg_p;
#endif
int octet_index, index;
#endif
if ((rlc_pP->output_sdu_in_construction)) { if ((rlc_pP->output_sdu_in_construction)) {
LOG_D(RLC, PROTOCOL_RLC_AM_CTXT_FMT"[SEND_SDU] %d bytes sdu %p\n", LOG_D(RLC, PROTOCOL_RLC_AM_CTXT_FMT"[SEND_SDU] %d bytes sdu %p\n",
PROTOCOL_RLC_AM_CTXT_ARGS(ctxt_pP,rlc_pP), PROTOCOL_RLC_AM_CTXT_ARGS(ctxt_pP,rlc_pP),
@@ -120,10 +106,13 @@ rlc_am_send_sdu (
rlc_pP->output_sdu_size_to_write, rlc_pP->output_sdu_size_to_write,
rlc_pP->output_sdu_in_construction); rlc_pP->output_sdu_in_construction);
#else #else
# if TRACE_RLC_AM_PDU
if ( LOG_DEBUGFLAG(DEBUG_RLC)) {
char message_string[7000];
size_t message_string_size = 0;
int octet_index, index;
message_string_size += sprintf(&message_string[message_string_size], "Bearer : %u\n", rlc_pP->rb_id); message_string_size += sprintf(&message_string[message_string_size], "Bearer : %u\n", rlc_pP->rb_id);
message_string_size += sprintf(&message_string[message_string_size], "SDU size : %u\n", rlc_pP->output_sdu_size_to_write); message_string_size += sprintf(&message_string[message_string_size], "SDU size : %u\n", rlc_pP->output_sdu_size_to_write);
message_string_size += sprintf(&message_string[message_string_size], "\nPayload : \n"); message_string_size += sprintf(&message_string[message_string_size], "\nPayload : \n");
message_string_size += sprintf(&message_string[message_string_size], "------+-------------------------------------------------|\n"); message_string_size += sprintf(&message_string[message_string_size], "------+-------------------------------------------------|\n");
message_string_size += sprintf(&message_string[message_string_size], " | 0 1 2 3 4 5 6 7 8 9 a b c d e f |\n"); message_string_size += sprintf(&message_string[message_string_size], " | 0 1 2 3 4 5 6 7 8 9 a b c d e f |\n");
@@ -157,22 +146,9 @@ rlc_am_send_sdu (
} }
message_string_size += sprintf(&message_string[message_string_size], " |\n"); message_string_size += sprintf(&message_string[message_string_size], " |\n");
# if ENABLE_ITTI
msg_p = itti_alloc_new_message_sized (ctxt_pP->enb_flag > 0 ? TASK_RLC_ENB:TASK_RLC_UE ,
RLC_AM_SDU_IND,
message_string_size + sizeof (IttiMsgText));
msg_p->ittiMsg.rlc_am_sdu_ind.size = message_string_size;
memcpy(&msg_p->ittiMsg.rlc_am_sdu_ind.text, message_string, message_string_size);
itti_send_msg_to_task(TASK_UNKNOWN, ctxt_pP->instance, msg_p);
# else
LOG_T(RLC, "%s", message_string); LOG_T(RLC, "%s", message_string);
# endif }
# endif
#if !ENABLE_ITTI #if !ENABLE_ITTI
RLC_AM_MUTEX_UNLOCK(&rlc_pP->lock_input_sdus); RLC_AM_MUTEX_UNLOCK(&rlc_pP->lock_input_sdus);
#endif #endif
@@ -186,7 +162,6 @@ rlc_am_send_sdu (
PROTOCOL_RLC_AM_MSC_ARGS(ctxt_pP,rlc_pP), PROTOCOL_RLC_AM_MSC_ARGS(ctxt_pP,rlc_pP),
rlc_pP->output_sdu_size_to_write rlc_pP->output_sdu_size_to_write
); );
rlc_data_ind (ctxt_pP, rlc_data_ind (ctxt_pP,
BOOL_NOT(rlc_pP->is_data_plane), BOOL_NOT(rlc_pP->is_data_plane),
MBMS_FLAG_NO, MBMS_FLAG_NO,
@@ -224,17 +199,16 @@ rlc_am_reassemble_pdu(
const protocol_ctxt_t *const ctxt_pP, const protocol_ctxt_t *const ctxt_pP,
rlc_am_entity_t *const rlc_pP, rlc_am_entity_t *const rlc_pP,
mem_block_t *const tb_pP, mem_block_t *const tb_pP,
boolean_t free_rlc_pdu) boolean_t free_rlc_pdu) {
{
int i,j; int i,j;
rlc_am_pdu_info_t *pdu_info = &((rlc_am_rx_pdu_management_t *)(tb_pP->data))->pdu_info; rlc_am_pdu_info_t *pdu_info = &((rlc_am_rx_pdu_management_t *)(tb_pP->data))->pdu_info;
LOG_D(RLC, PROTOCOL_RLC_AM_CTXT_FMT"[REASSEMBLY PDU] TRY REASSEMBLY PDU SN=%03d\n", LOG_D(RLC, PROTOCOL_RLC_AM_CTXT_FMT"[REASSEMBLY PDU] TRY REASSEMBLY PDU SN=%03d\n",
PROTOCOL_RLC_AM_CTXT_ARGS(ctxt_pP,rlc_pP), PROTOCOL_RLC_AM_CTXT_ARGS(ctxt_pP,rlc_pP),
pdu_info->sn); pdu_info->sn);
#if TRACE_RLC_AM_RX_DECODE
if ( LOG_DEBUGFLAG(DEBUG_RLC)) {
rlc_am_display_data_pdu_infos(ctxt_pP, rlc_pP, pdu_info); rlc_am_display_data_pdu_infos(ctxt_pP, rlc_pP, pdu_info);
#endif }
if (pdu_info->e == RLC_E_FIXED_PART_DATA_FIELD_FOLLOW) { if (pdu_info->e == RLC_E_FIXED_PART_DATA_FIELD_FOLLOW) {
switch (pdu_info->fi) { switch (pdu_info->fi) {
@@ -277,7 +251,6 @@ rlc_am_reassemble_pdu(
//} else { //} else {
// rlc_pP->reassembly_missing_sn_detected = 1; // not necessary but for readability of the code // rlc_pP->reassembly_missing_sn_detected = 1; // not necessary but for readability of the code
//} //}
break; break;
default: default:
openair2/LAYER2/RLC/AM_v9.3.0/rlc_am_status_report.c
+34 -143
View File
@@ -34,52 +34,12 @@
#include "rlc_am.h" #include "rlc_am.h"
#include "common/utils/LOG/log.h" #include "common/utils/LOG/log.h"
# if ENABLE_ITTI
//-----------------------------------------------------------------------------
void
rlc_am_itti_display_status_ind_infos(
const protocol_ctxt_t* const ctxt_pP,
const rlc_am_entity_t *const rlc_pP,
const rlc_am_control_pdu_info_t *const pdu_info_pP)
{
char message_string[1000];
size_t message_string_size = 0;
MessageDef *msg_p;
int num_nack;
if (!pdu_info_pP->d_c) {
message_string_size += sprintf(&message_string[message_string_size], "Bearer : %u\n", rlc_pP->rb_id);
message_string_size += sprintf(&message_string[message_string_size], "CONTROL PDU ACK SN %04d", pdu_info_pP->ack_sn);
for (num_nack = 0; num_nack < pdu_info_pP->num_nack; num_nack++) {
if (pdu_info_pP->nack_list[num_nack].e2) {
message_string_size += sprintf(&message_string[message_string_size], "\n\tNACK SN %04d SO START %05d SO END %05d", pdu_info_pP->nack_list[num_nack].nack_sn,
pdu_info_pP->nack_list[num_nack].so_start,
pdu_info_pP->nack_list[num_nack].so_end);
} else {
message_string_size += sprintf(&message_string[message_string_size], "\n\tNACK SN %04d", pdu_info_pP->nack_list[num_nack].nack_sn);
}
}
message_string_size += sprintf(&message_string[message_string_size], "\n");
msg_p = itti_alloc_new_message_sized (ctxt_pP->enb_flag > 0 ? TASK_RLC_ENB:TASK_RLC_UE , RLC_AM_STATUS_PDU_IND, message_string_size + sizeof (IttiMsgText));
msg_p->ittiMsg.rlc_am_status_pdu_ind.size = message_string_size;
memcpy(&msg_p->ittiMsg.rlc_am_status_pdu_ind.text, message_string, message_string_size);
itti_send_msg_to_task(TASK_UNKNOWN, ctxt_pP->instance, msg_p);
}
}
# endif
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
uint16_t rlc_am_read_bit_field( uint16_t rlc_am_read_bit_field(
uint8_t **data_ppP, uint8_t **data_ppP,
unsigned int *bit_pos_pP, unsigned int *bit_pos_pP,
const signed int bits_to_readP) const signed int bits_to_readP) {
{
uint16_t value = 0; uint16_t value = 0;
unsigned int bits_read = 0; unsigned int bits_read = 0;
signed int bits_to_read = bits_to_readP; signed int bits_to_read = bits_to_readP;
@@ -116,8 +76,7 @@ rlc_am_write8_bit_field(
uint8_t **data_ppP, uint8_t **data_ppP,
unsigned int *bit_pos_pP, unsigned int *bit_pos_pP,
const signed int bits_to_writeP, const signed int bits_to_writeP,
const uint8_t valueP) const uint8_t valueP) {
{
unsigned int available_bits; unsigned int available_bits;
signed int bits_to_write= bits_to_writeP; signed int bits_to_write= bits_to_writeP;
@@ -151,8 +110,7 @@ rlc_am_write16_bit_field(
uint8_t **data_ppP, uint8_t **data_ppP,
unsigned int *bit_pos_pP, unsigned int *bit_pos_pP,
signed int bits_to_writeP, signed int bits_to_writeP,
const uint16_t valueP) const uint16_t valueP) {
{
//assert(bits_to_writeP <= 16); //assert(bits_to_writeP <= 16);
if(bits_to_writeP > 16) { if(bits_to_writeP > 16) {
LOG_E(RLC, "bits_to_writeP error. %d\n", bits_to_writeP); LOG_E(RLC, "bits_to_writeP error. %d\n", bits_to_writeP);
@@ -170,13 +128,10 @@ signed int
rlc_am_get_control_pdu_infos( rlc_am_get_control_pdu_infos(
rlc_am_pdu_sn_10_t *const header_pP, rlc_am_pdu_sn_10_t *const header_pP,
sdu_size_t *const total_size_pP, sdu_size_t *const total_size_pP,
rlc_am_control_pdu_info_t* const pdu_info_pP) rlc_am_control_pdu_info_t *const pdu_info_pP) {
{
memset(pdu_info_pP, 0, sizeof (rlc_am_control_pdu_info_t)); memset(pdu_info_pP, 0, sizeof (rlc_am_control_pdu_info_t));
pdu_info_pP->d_c = header_pP->b1 >> 7; pdu_info_pP->d_c = header_pP->b1 >> 7;
if (!pdu_info_pP->d_c) { if (!pdu_info_pP->d_c) {
pdu_info_pP->cpt = (header_pP->b1 >> 4) & 0x07; pdu_info_pP->cpt = (header_pP->b1 >> 4) & 0x07;
@@ -214,9 +169,11 @@ rlc_am_get_control_pdu_infos(
if (!pdu_info_pP->nack_list[pdu_info_pP->num_nack - 1].e1) { if (!pdu_info_pP->nack_list[pdu_info_pP->num_nack - 1].e1) {
nack_to_read = 0; nack_to_read = 0;
*total_size_pP = *total_size_pP - (sdu_size_t)((uint64_t)byte_pos_p + (uint64_t)((bit_pos + 7)/8) - (uint64_t)header_pP); *total_size_pP = *total_size_pP - (sdu_size_t)((uint64_t)byte_pos_p + (uint64_t)((bit_pos + 7)/8) - (uint64_t)header_pP);
if (*total_size_pP != 0) { if (*total_size_pP != 0) {
LOG_E(RLC, "[RLC_AM_GET_CONTROL_PDU_INFOS][FIRST]header_pP->b1=%d,header_pP->b2=%d\n",header_pP->b1,header_pP->b2); LOG_E(RLC, "[RLC_AM_GET_CONTROL_PDU_INFOS][FIRST]header_pP->b1=%d,header_pP->b2=%d\n",header_pP->b1,header_pP->b2);
} }
return 0; return 0;
} }
@@ -230,9 +187,11 @@ rlc_am_get_control_pdu_infos(
} else { } else {
*total_size_pP = *total_size_pP - 2; *total_size_pP = *total_size_pP - 2;
} }
if (*total_size_pP != 0) { if (*total_size_pP != 0) {
LOG_E(RLC, "[RLC_AM_GET_CONTROL_PDU_INFOS][SECOND]header_pP->b1=%d,header_pP->b2=%d\n",header_pP->b1,header_pP->b2); LOG_E(RLC, "[RLC_AM_GET_CONTROL_PDU_INFOS][SECOND]header_pP->b1=%d,header_pP->b2=%d\n",header_pP->b1,header_pP->b2);
} }
return 0; return 0;
} else { } else {
return -1; return -1;
@@ -242,8 +201,7 @@ rlc_am_get_control_pdu_infos(
void void
rlc_am_display_control_pdu_infos( rlc_am_display_control_pdu_infos(
const rlc_am_control_pdu_info_t *const pdu_info_pP const rlc_am_control_pdu_info_t *const pdu_info_pP
) ) {
{
int num_nack; int num_nack;
if (!pdu_info_pP->d_c) { if (!pdu_info_pP->d_c) {
@@ -271,8 +229,7 @@ rlc_am_receive_process_control_pdu(
rlc_am_entity_t *const rlc_pP, rlc_am_entity_t *const rlc_pP,
mem_block_t *const tb_pP, mem_block_t *const tb_pP,
uint8_t **first_byte_ppP, uint8_t **first_byte_ppP,
sdu_size_t * const tb_size_in_bytes_pP) sdu_size_t *const tb_size_in_bytes_pP) {
{
rlc_am_pdu_sn_10_t *rlc_am_pdu_sn_10_p = (rlc_am_pdu_sn_10_t *)*first_byte_ppP; rlc_am_pdu_sn_10_t *rlc_am_pdu_sn_10_p = (rlc_am_pdu_sn_10_t *)*first_byte_ppP;
sdu_size_t initial_pdu_size = *tb_size_in_bytes_pP; sdu_size_t initial_pdu_size = *tb_size_in_bytes_pP;
rlc_sn_t ack_sn = RLC_AM_NEXT_SN(rlc_pP->vt_a); rlc_sn_t ack_sn = RLC_AM_NEXT_SN(rlc_pP->vt_a);
@@ -285,7 +242,6 @@ rlc_am_receive_process_control_pdu(
boolean_t status = TRUE; boolean_t status = TRUE;
if (rlc_am_get_control_pdu_infos(rlc_am_pdu_sn_10_p, tb_size_in_bytes_pP, &rlc_pP->control_pdu_info) >= 0) { if (rlc_am_get_control_pdu_infos(rlc_am_pdu_sn_10_p, tb_size_in_bytes_pP, &rlc_pP->control_pdu_info) >= 0) {
rlc_am_tx_buffer_display(ctxt_pP, rlc_pP, " TX BUFFER BEFORE PROCESS OF STATUS PDU"); rlc_am_tx_buffer_display(ctxt_pP, rlc_pP, " TX BUFFER BEFORE PROCESS OF STATUS PDU");
LOG_D(RLC, PROTOCOL_RLC_AM_CTXT_FMT" RX CONTROL PDU VT(A) %04d VT(S) %04d POLL_SN %04d ACK_SN %04d\n", LOG_D(RLC, PROTOCOL_RLC_AM_CTXT_FMT" RX CONTROL PDU VT(A) %04d VT(S) %04d POLL_SN %04d ACK_SN %04d\n",
PROTOCOL_RLC_AM_CTXT_ARGS(ctxt_pP,rlc_pP), PROTOCOL_RLC_AM_CTXT_ARGS(ctxt_pP,rlc_pP),
@@ -294,7 +250,6 @@ rlc_am_receive_process_control_pdu(
rlc_pP->poll_sn, rlc_pP->poll_sn,
rlc_pP->control_pdu_info.ack_sn); rlc_pP->control_pdu_info.ack_sn);
rlc_am_display_control_pdu_infos(&rlc_pP->control_pdu_info); rlc_am_display_control_pdu_infos(&rlc_pP->control_pdu_info);
ack_sn = rlc_pP->control_pdu_info.ack_sn; ack_sn = rlc_pP->control_pdu_info.ack_sn;
// 5.2.1 Retransmission // 5.2.1 Retransmission
// //
@@ -326,8 +281,7 @@ rlc_am_receive_process_control_pdu(
/* Note : ackSn can be equal to current vtA only in case the status pdu contains a list of nack_sn with same value = vtA with SOStart/SOEnd */ /* Note : ackSn can be equal to current vtA only in case the status pdu contains a list of nack_sn with same value = vtA with SOStart/SOEnd */
/* and meaning the report is not complete due to not enough ressources to fill all SOStart/SOEnd of this NACK_SN */ /* and meaning the report is not complete due to not enough ressources to fill all SOStart/SOEnd of this NACK_SN */
if (RLC_AM_DIFF_SN(rlc_pP->vt_s,rlc_pP->vt_a) >= RLC_AM_DIFF_SN(ack_sn,rlc_pP->vt_a)) if (RLC_AM_DIFF_SN(rlc_pP->vt_s,rlc_pP->vt_a) >= RLC_AM_DIFF_SN(ack_sn,rlc_pP->vt_a)) {
{
if (rlc_pP->control_pdu_info.num_nack == 0) { if (rlc_pP->control_pdu_info.num_nack == 0) {
while (sn_cursor != ack_sn) { while (sn_cursor != ack_sn) {
rlc_am_ack_pdu(ctxt_pP, rlc_pP, sn_cursor,TRUE); rlc_am_ack_pdu(ctxt_pP, rlc_pP, sn_cursor,TRUE);
@@ -347,21 +301,18 @@ rlc_am_receive_process_control_pdu(
} }
vt_a_new = nack_sn; vt_a_new = nack_sn;
// catch DataCfn // catch DataCfn
rlc_am_tx_data_pdu_management_t *tx_data_pdu_buffer_p = &rlc_pP->tx_data_pdu_buffer[nack_sn % RLC_AM_WINDOW_SIZE]; rlc_am_tx_data_pdu_management_t *tx_data_pdu_buffer_p = &rlc_pP->tx_data_pdu_buffer[nack_sn % RLC_AM_WINDOW_SIZE];
if (tx_data_pdu_buffer_p->retx_payload_size == tx_data_pdu_buffer_p->payload_size) { if (tx_data_pdu_buffer_p->retx_payload_size == tx_data_pdu_buffer_p->payload_size) {
sn_data_cnf = RLC_AM_PREV_SN(nack_sn); sn_data_cnf = RLC_AM_PREV_SN(nack_sn);
} } else if (tx_data_pdu_buffer_p->nack_so_start != 0) {
else if (tx_data_pdu_buffer_p->nack_so_start != 0) {
sn_data_cnf = nack_sn; sn_data_cnf = nack_sn;
data_cnf_so_stop = tx_data_pdu_buffer_p->nack_so_start - 1; data_cnf_so_stop = tx_data_pdu_buffer_p->nack_so_start - 1;
} } else {
else {
sn_data_cnf = RLC_AM_PREV_SN(nack_sn); sn_data_cnf = RLC_AM_PREV_SN(nack_sn);
} }
while ((sn_cursor != ack_sn) && (status)) { while ((sn_cursor != ack_sn) && (status)) {
if (sn_cursor != nack_sn) { if (sn_cursor != nack_sn) {
rlc_am_ack_pdu(ctxt_pP, rlc_am_ack_pdu(ctxt_pP,
@@ -375,30 +326,26 @@ rlc_am_receive_process_control_pdu(
prev_nack_sn, prev_nack_sn,
rlc_pP->control_pdu_info.nack_list[nack_index].so_start, rlc_pP->control_pdu_info.nack_list[nack_index].so_start,
rlc_pP->control_pdu_info.nack_list[nack_index].so_end); rlc_pP->control_pdu_info.nack_list[nack_index].so_end);
nack_index = nack_index + 1; nack_index = nack_index + 1;
prev_nack_sn = nack_sn; prev_nack_sn = nack_sn;
if (nack_index < rlc_pP->control_pdu_info.num_nack) { if (nack_index < rlc_pP->control_pdu_info.num_nack) {
nack_sn = rlc_pP->control_pdu_info.nack_list[nack_index].nack_sn; nack_sn = rlc_pP->control_pdu_info.nack_list[nack_index].nack_sn;
} } else if (nack_sn != ack_sn) {
else if (nack_sn != ack_sn) {
/* general case*/ /* general case*/
nack_sn = ack_sn; nack_sn = ack_sn;
} } else {
else {
/*specific case when the sender did not have enough TBS to fill all SOStart SOEnd for this NACK_SN */ /*specific case when the sender did not have enough TBS to fill all SOStart SOEnd for this NACK_SN */
break; break;
} }
} }
if (prev_nack_sn != nack_sn) { if (prev_nack_sn != nack_sn) {
/* do not increment sn_cursor in case of several informations for the same nack_sn */ /* do not increment sn_cursor in case of several informations for the same nack_sn */
sn_cursor = (sn_cursor + 1) & RLC_AM_SN_MASK; sn_cursor = (sn_cursor + 1) & RLC_AM_SN_MASK;
} }
} }
} }
} else { } else {
LOG_E(RLC, PROTOCOL_RLC_AM_CTXT_FMT" WARNING CONTROL PDU ACK SN %d OUT OF WINDOW vtA=%d vtS=%d\n", LOG_E(RLC, PROTOCOL_RLC_AM_CTXT_FMT" WARNING CONTROL PDU ACK SN %d OUT OF WINDOW vtA=%d vtS=%d\n",
PROTOCOL_RLC_AM_CTXT_ARGS(ctxt_pP,rlc_pP),ack_sn,rlc_pP->vt_a,rlc_pP->vt_s); PROTOCOL_RLC_AM_CTXT_ARGS(ctxt_pP,rlc_pP),ack_sn,rlc_pP->vt_a,rlc_pP->vt_s);
@@ -439,8 +386,7 @@ rlc_am_receive_process_control_pdu(
LOG_D(RLC, PROTOCOL_RLC_AM_CTXT_FMT" RECEIVE STATUS PDU ACK_SN=%d NewvtA=%d OldvtA=%d SnDataCnf=%d DataCnfSOStop=%d vtS=%d\n", LOG_D(RLC, PROTOCOL_RLC_AM_CTXT_FMT" RECEIVE STATUS PDU ACK_SN=%d NewvtA=%d OldvtA=%d SnDataCnf=%d DataCnfSOStop=%d vtS=%d\n",
PROTOCOL_RLC_AM_CTXT_ARGS(ctxt_pP,rlc_pP),ack_sn,vt_a_new,rlc_pP->vt_a,sn_data_cnf,data_cnf_so_stop,rlc_pP->vt_s); PROTOCOL_RLC_AM_CTXT_ARGS(ctxt_pP,rlc_pP),ack_sn,vt_a_new,rlc_pP->vt_a,sn_data_cnf,data_cnf_so_stop,rlc_pP->vt_s);
} } else {
else {
LOG_D(RLC, PROTOCOL_RLC_AM_CTXT_FMT" RECEIVE STATUS PDU WITH NO SDU CNF ACK_SN=%d NewvtA=%d OldvtA=%d vtS=%d\n", LOG_D(RLC, PROTOCOL_RLC_AM_CTXT_FMT" RECEIVE STATUS PDU WITH NO SDU CNF ACK_SN=%d NewvtA=%d OldvtA=%d vtS=%d\n",
PROTOCOL_RLC_AM_CTXT_ARGS(ctxt_pP,rlc_pP),ack_sn,vt_a_new,rlc_pP->vt_a,rlc_pP->vt_s); PROTOCOL_RLC_AM_CTXT_ARGS(ctxt_pP,rlc_pP),ack_sn,vt_a_new,rlc_pP->vt_a,rlc_pP->vt_s);
} }
@@ -451,7 +397,6 @@ rlc_am_receive_process_control_pdu(
} }
*first_byte_ppP = (uint8_t *)((uint64_t)*first_byte_ppP + initial_pdu_size - *tb_size_in_bytes_pP); *first_byte_ppP = (uint8_t *)((uint64_t)*first_byte_ppP + initial_pdu_size - *tb_size_in_bytes_pP);
free_mem_block(tb_pP, __func__); free_mem_block(tb_pP, __func__);
rlc_am_tx_buffer_display(ctxt_pP, rlc_pP, NULL); rlc_am_tx_buffer_display(ctxt_pP, rlc_pP, NULL);
} }
@@ -461,13 +406,11 @@ rlc_am_write_status_pdu(
const protocol_ctxt_t *const ctxt_pP, const protocol_ctxt_t *const ctxt_pP,
rlc_am_entity_t *const rlc_pP, rlc_am_entity_t *const rlc_pP,
rlc_am_pdu_sn_10_t *const rlc_am_pdu_sn_10_pP, rlc_am_pdu_sn_10_t *const rlc_am_pdu_sn_10_pP,
rlc_am_control_pdu_info_t* const pdu_info_pP) rlc_am_control_pdu_info_t *const pdu_info_pP) {
{
unsigned int bit_pos = 4; // range from 0 (MSB/left) to 7 (LSB/right) unsigned int bit_pos = 4; // range from 0 (MSB/left) to 7 (LSB/right)
uint8_t *byte_pos_p = &rlc_am_pdu_sn_10_pP->b1; uint8_t *byte_pos_p = &rlc_am_pdu_sn_10_pP->b1;
unsigned int index = 0; unsigned int index = 0;
unsigned int num_bytes = 0; unsigned int num_bytes = 0;
rlc_am_write16_bit_field(&byte_pos_p, &bit_pos, 10, pdu_info_pP->ack_sn); rlc_am_write16_bit_field(&byte_pos_p, &bit_pos, 10, pdu_info_pP->ack_sn);
if (pdu_info_pP->num_nack > 0) { if (pdu_info_pP->num_nack > 0) {
@@ -495,11 +438,9 @@ rlc_am_write_status_pdu(
num_bytes += 1; num_bytes += 1;
} }
#if TRACE_RLC_AM_STATUS_CREATION
LOG_D(RLC, PROTOCOL_RLC_AM_CTXT_FMT" WROTE STATUS PDU %d BYTES\n", LOG_D(RLC, PROTOCOL_RLC_AM_CTXT_FMT" WROTE STATUS PDU %d BYTES\n",
PROTOCOL_RLC_AM_CTXT_ARGS(ctxt_pP,rlc_pP), PROTOCOL_RLC_AM_CTXT_ARGS(ctxt_pP,rlc_pP),
num_bytes); num_bytes);
#endif
return num_bytes; return num_bytes;
} }
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
@@ -507,8 +448,7 @@ void
rlc_am_send_status_pdu( rlc_am_send_status_pdu(
const protocol_ctxt_t *const ctxt_pP, const protocol_ctxt_t *const ctxt_pP,
rlc_am_entity_t *const rlc_pP rlc_am_entity_t *const rlc_pP
) ) {
{
// When STATUS reporting has been triggered, the receiving side of an AM RLC entity shall: // When STATUS reporting has been triggered, the receiving side of an AM RLC entity shall:
// - if t-StatusProhibit is not running: // - if t-StatusProhibit is not running:
// - at the first transmission opportunity indicated by lower layer, construct a STATUS PDU and deliver it to lower layer; // - at the first transmission opportunity indicated by lower layer, construct a STATUS PDU and deliver it to lower layer;
@@ -530,7 +470,6 @@ rlc_am_send_status_pdu(
// - include in the STATUS PDU a set of NACK_SN, SOstart and SOend // - include in the STATUS PDU a set of NACK_SN, SOstart and SOend
// - set the ACK_SN to the SN of the next not received RLC Data PDU which is not indicated as missing in the // - set the ACK_SN to the SN of the next not received RLC Data PDU which is not indicated as missing in the
// resulting STATUS PDU. // resulting STATUS PDU.
signed int nb_bits_to_transmit = rlc_pP->nb_bytes_requested_by_mac << 3; signed int nb_bits_to_transmit = rlc_pP->nb_bytes_requested_by_mac << 3;
// minimum header size in bits to be transmitted: D/C + CPT + ACK_SN + E1 // minimum header size in bits to be transmitted: D/C + CPT + ACK_SN + E1
signed int nb_bits_transmitted = RLC_AM_PDU_D_C_BITS + RLC_AM_STATUS_PDU_CPT_LENGTH + RLC_AM_SN_BITS + RLC_AM_PDU_E_BITS; signed int nb_bits_transmitted = RLC_AM_PDU_D_C_BITS + RLC_AM_STATUS_PDU_CPT_LENGTH + RLC_AM_SN_BITS + RLC_AM_PDU_E_BITS;
@@ -545,33 +484,23 @@ rlc_am_send_status_pdu(
sdu_size_t pdu_size = 0; sdu_size_t pdu_size = 0;
boolean_t status_report_completed = false; boolean_t status_report_completed = false;
boolean_t segment_loop_end = false; boolean_t segment_loop_end = false;
memset(&control_pdu_info, 0, sizeof(rlc_am_control_pdu_info_t)); memset(&control_pdu_info, 0, sizeof(rlc_am_control_pdu_info_t));
#if TRACE_RLC_AM_STATUS_CREATION
LOG_D(RLC, PROTOCOL_RLC_AM_CTXT_FMT"[SEND-STATUS] nb_bits_to_transmit %d (15 already allocated for header)\n", LOG_D(RLC, PROTOCOL_RLC_AM_CTXT_FMT"[SEND-STATUS] nb_bits_to_transmit %d (15 already allocated for header)\n",
PROTOCOL_RLC_AM_CTXT_ARGS(ctxt_pP,rlc_pP), PROTOCOL_RLC_AM_CTXT_ARGS(ctxt_pP,rlc_pP),
nb_bits_to_transmit); nb_bits_to_transmit);
rlc_am_rx_list_display(rlc_pP, " DISPLAY BEFORE CONSTRUCTION OF STATUS REPORT"); rlc_am_rx_list_display(rlc_pP, " DISPLAY BEFORE CONSTRUCTION OF STATUS REPORT");
#endif
/* Handle no NACK first */ /* Handle no NACK first */
if (rlc_pP->vr_r == rlc_pP->vr_ms) { if (rlc_pP->vr_r == rlc_pP->vr_ms) {
control_pdu_info.ack_sn = rlc_pP->vr_ms; control_pdu_info.ack_sn = rlc_pP->vr_ms;
status_report_completed = true; status_report_completed = true;
#if TRACE_RLC_AM_STATUS_CREATION
LOG_D(RLC, PROTOCOL_RLC_AM_CTXT_FMT"[SEND-STATUS] LINE %d ALL ACK WITH ACK_SN %04d\n", LOG_D(RLC, PROTOCOL_RLC_AM_CTXT_FMT"[SEND-STATUS] LINE %d ALL ACK WITH ACK_SN %04d\n",
PROTOCOL_RLC_AM_CTXT_ARGS(ctxt_pP,rlc_pP), PROTOCOL_RLC_AM_CTXT_ARGS(ctxt_pP,rlc_pP),
__LINE__, __LINE__,
rlc_pP->vr_ms); rlc_pP->vr_ms);
#endif } else if ((cursor_p != NULL) && ((nb_bits_transmitted + RLC_AM_SN_BITS + (RLC_AM_PDU_E_BITS << 1)) <= nb_bits_to_transmit)) {
}
else if ((cursor_p != NULL) && ((nb_bits_transmitted + RLC_AM_SN_BITS + (RLC_AM_PDU_E_BITS << 1)) <= nb_bits_to_transmit)) {
pdu_info_cursor_p = &((rlc_am_rx_pdu_management_t *)(cursor_p->data))->pdu_info; pdu_info_cursor_p = &((rlc_am_rx_pdu_management_t *)(cursor_p->data))->pdu_info;
sn_cursor = pdu_info_cursor_p->sn; sn_cursor = pdu_info_cursor_p->sn;
/* Set E1 bit for the presence of first NACK_SN/E1/E2 */ /* Set E1 bit for the presence of first NACK_SN/E1/E2 */
control_pdu_info.e1 = 1; control_pdu_info.e1 = 1;
@@ -579,7 +508,6 @@ rlc_am_send_status_pdu(
// 42 bits = size of NACK_SN field + SO_START, SO_END fields, E1, E2 bits // 42 bits = size of NACK_SN field + SO_START, SO_END fields, E1, E2 bits
while ((!status_report_completed) && (RLC_AM_DIFF_SN(sn_nack,rlc_pP->vr_r) < RLC_AM_DIFF_SN(rlc_pP->vr_ms,rlc_pP->vr_r)) while ((!status_report_completed) && (RLC_AM_DIFF_SN(sn_nack,rlc_pP->vr_r) < RLC_AM_DIFF_SN(rlc_pP->vr_ms,rlc_pP->vr_r))
&& (cursor_p != NULL) && (nb_bits_transmitted <= nb_bits_to_transmit)) { && (cursor_p != NULL) && (nb_bits_transmitted <= nb_bits_to_transmit)) {
pdu_info_cursor_p = &((rlc_am_rx_pdu_management_t *)(cursor_p->data))->pdu_info; pdu_info_cursor_p = &((rlc_am_rx_pdu_management_t *)(cursor_p->data))->pdu_info;
sn_cursor = pdu_info_cursor_p->sn; sn_cursor = pdu_info_cursor_p->sn;
all_segments_received = ((rlc_am_rx_pdu_management_t *)(cursor_p->data))->all_segments_received; all_segments_received = ((rlc_am_rx_pdu_management_t *)(cursor_p->data))->all_segments_received;
@@ -596,25 +524,20 @@ rlc_am_send_status_pdu(
control_pdu_info.nack_list[control_pdu_info.num_nack].e1 = 1; control_pdu_info.nack_list[control_pdu_info.num_nack].e1 = 1;
control_pdu_info.num_nack += 1; control_pdu_info.num_nack += 1;
nb_bits_transmitted += (RLC_AM_SN_BITS + (RLC_AM_PDU_E_BITS << 1)); nb_bits_transmitted += (RLC_AM_SN_BITS + (RLC_AM_PDU_E_BITS << 1));
#if TRACE_RLC_AM_STATUS_CREATION
LOG_D(RLC, PROTOCOL_RLC_AM_CTXT_FMT"[SEND-STATUS] LINE %d PREPARE SENDING NACK %04d\n", LOG_D(RLC, PROTOCOL_RLC_AM_CTXT_FMT"[SEND-STATUS] LINE %d PREPARE SENDING NACK %04d\n",
PROTOCOL_RLC_AM_CTXT_ARGS(ctxt_pP,rlc_pP), PROTOCOL_RLC_AM_CTXT_ARGS(ctxt_pP,rlc_pP),
__LINE__, __LINE__,
sn_nack); sn_nack);
#endif
sn_nack = RLC_AM_NEXT_SN(sn_nack); sn_nack = RLC_AM_NEXT_SN(sn_nack);
} } else {
else {
/* Not enough UL TBS*/ /* Not enough UL TBS*/
/* latest value of sn_nack shall be used as ACK_SN */ /* latest value of sn_nack shall be used as ACK_SN */
control_pdu_info.ack_sn = sn_nack; control_pdu_info.ack_sn = sn_nack;
status_report_completed = true; status_report_completed = true;
#if TRACE_RLC_AM_STATUS_CREATION
LOG_D(RLC, PROTOCOL_RLC_AM_CTXT_FMT"[SEND-STATUS] LINE %d NOT ENOUGH TBS STOP WITH ACK_SN %04d\n", LOG_D(RLC, PROTOCOL_RLC_AM_CTXT_FMT"[SEND-STATUS] LINE %d NOT ENOUGH TBS STOP WITH ACK_SN %04d\n",
PROTOCOL_RLC_AM_CTXT_ARGS(ctxt_pP,rlc_pP), PROTOCOL_RLC_AM_CTXT_ARGS(ctxt_pP,rlc_pP),
__LINE__, __LINE__,
sn_nack); sn_nack);
#endif
break; break;
} }
} }
@@ -629,7 +552,6 @@ rlc_am_send_status_pdu(
if(sn_nack != sn_cursor) { if(sn_nack != sn_cursor) {
LOG_E(RLC, "RLC AM Tx Status PDU Data sn_nack=%d and sn_cursor=%d should be equal LcId=%d\n",sn_nack,sn_cursor, rlc_pP->channel_id); LOG_E(RLC, "RLC AM Tx Status PDU Data sn_nack=%d and sn_cursor=%d should be equal LcId=%d\n",sn_nack,sn_cursor, rlc_pP->channel_id);
} }
/* First ensure there is enough TBS for at least 1 SOStart/SOEnd, else break */ /* First ensure there is enough TBS for at least 1 SOStart/SOEnd, else break */
else if ((nb_bits_transmitted + RLC_AM_SN_BITS + (RLC_AM_PDU_E_BITS << 1) + (RLC_AM_STATUS_PDU_SO_LENGTH << 1)) <= nb_bits_to_transmit) { else if ((nb_bits_transmitted + RLC_AM_SN_BITS + (RLC_AM_PDU_E_BITS << 1) + (RLC_AM_STATUS_PDU_SO_LENGTH << 1)) <= nb_bits_to_transmit) {
/* Init loop flags */ /* Init loop flags */
@@ -647,31 +569,27 @@ rlc_am_send_status_pdu(
control_pdu_info.nack_list[control_pdu_info.num_nack].e1 = 1; control_pdu_info.nack_list[control_pdu_info.num_nack].e1 = 1;
control_pdu_info.num_nack += 1; control_pdu_info.num_nack += 1;
nb_bits_transmitted += (RLC_AM_SN_BITS + (RLC_AM_PDU_E_BITS << 1) + (RLC_AM_STATUS_PDU_SO_LENGTH << 1)); nb_bits_transmitted += (RLC_AM_SN_BITS + (RLC_AM_PDU_E_BITS << 1) + (RLC_AM_STATUS_PDU_SO_LENGTH << 1));
#if TRACE_RLC_AM_STATUS_CREATION
LOG_D(RLC, PROTOCOL_RLC_AM_CTXT_FMT"[SEND-STATUS] LINE %d PREPARE SENDING NACK %04d SO START %05d SO END %05d\n", LOG_D(RLC, PROTOCOL_RLC_AM_CTXT_FMT"[SEND-STATUS] LINE %d PREPARE SENDING NACK %04d SO START %05d SO END %05d\n",
PROTOCOL_RLC_AM_CTXT_ARGS(ctxt_pP,rlc_pP), PROTOCOL_RLC_AM_CTXT_ARGS(ctxt_pP,rlc_pP),
__LINE__, __LINE__,
sn_cursor, sn_cursor,
0, 0,
pdu_info_cursor_p->so - 1); pdu_info_cursor_p->so - 1);
#endif
waited_so = pdu_info_cursor_p->so + pdu_info_cursor_p->payload_size; waited_so = pdu_info_cursor_p->so + pdu_info_cursor_p->payload_size;
} } else {
else {
waited_so = pdu_info_cursor_p->payload_size; waited_so = pdu_info_cursor_p->payload_size;
} }
/* Go to next segment */ /* Go to next segment */
cursor_p = cursor_p->next; cursor_p = cursor_p->next;
if (cursor_p != NULL)
{ if (cursor_p != NULL) {
pdu_info_cursor_p = &((rlc_am_rx_pdu_management_t *)(cursor_p->data))->pdu_info; pdu_info_cursor_p = &((rlc_am_rx_pdu_management_t *)(cursor_p->data))->pdu_info;
} }
/* Find the first discontinuity and then fill SOStart/SOEnd */ /* Find the first discontinuity and then fill SOStart/SOEnd */
while (!segment_loop_end) { while (!segment_loop_end) {
if ((cursor_p != NULL) && (pdu_info_cursor_p->sn == sn_cursor)) { if ((cursor_p != NULL) && (pdu_info_cursor_p->sn == sn_cursor)) {
/* PDU segment is for the same SN*/ /* PDU segment is for the same SN*/
/* Check lsf */ /* Check lsf */
segment_loop_end = (pdu_info_cursor_p->lsf == 1); segment_loop_end = (pdu_info_cursor_p->lsf == 1);
@@ -687,24 +605,20 @@ rlc_am_send_status_pdu(
control_pdu_info.nack_list[control_pdu_info.num_nack].e1 = 1; control_pdu_info.nack_list[control_pdu_info.num_nack].e1 = 1;
control_pdu_info.num_nack += 1; control_pdu_info.num_nack += 1;
nb_bits_transmitted += (RLC_AM_SN_BITS + (RLC_AM_PDU_E_BITS << 1) + (RLC_AM_STATUS_PDU_SO_LENGTH << 1)); nb_bits_transmitted += (RLC_AM_SN_BITS + (RLC_AM_PDU_E_BITS << 1) + (RLC_AM_STATUS_PDU_SO_LENGTH << 1));
#if TRACE_RLC_AM_STATUS_CREATION
LOG_D(RLC, PROTOCOL_RLC_AM_CTXT_FMT"[SEND-STATUS] LINE %d PREPARE SENDING NACK %04d SO START %05d SO END %05d\n", LOG_D(RLC, PROTOCOL_RLC_AM_CTXT_FMT"[SEND-STATUS] LINE %d PREPARE SENDING NACK %04d SO START %05d SO END %05d\n",
PROTOCOL_RLC_AM_CTXT_ARGS(ctxt_pP,rlc_pP), PROTOCOL_RLC_AM_CTXT_ARGS(ctxt_pP,rlc_pP),
__LINE__, __LINE__,
sn_cursor, sn_cursor,
waited_so, waited_so,
pdu_info_cursor_p->so); pdu_info_cursor_p->so);
#endif } else {
}
else {
/* Not enough resources to set a SOStart/SEnd, then set ACK_SN to current NACK_SN and stop Status PDU build */ /* Not enough resources to set a SOStart/SEnd, then set ACK_SN to current NACK_SN and stop Status PDU build */
control_pdu_info.ack_sn = sn_cursor; control_pdu_info.ack_sn = sn_cursor;
status_report_completed = true; status_report_completed = true;
segment_loop_end = true; segment_loop_end = true;
break; break;
} }
} } else {
else {
/* contiguous segment: only update waited_so */ /* contiguous segment: only update waited_so */
/* Assuming so and payload_size updated according to duplication removal done at reception ... */ /* Assuming so and payload_size updated according to duplication removal done at reception ... */
waited_so += pdu_info_cursor_p->payload_size; waited_so += pdu_info_cursor_p->payload_size;
@@ -712,11 +626,10 @@ rlc_am_send_status_pdu(
/* Go to next received PDU or PDU Segment */ /* Go to next received PDU or PDU Segment */
cursor_p = cursor_p->next; cursor_p = cursor_p->next;
if (cursor_p != NULL)
{ if (cursor_p != NULL) {
pdu_info_cursor_p = &((rlc_am_rx_pdu_management_t *)(cursor_p->data))->pdu_info; pdu_info_cursor_p = &((rlc_am_rx_pdu_management_t *)(cursor_p->data))->pdu_info;
} }
} //end if (cursor_p != NULL) && (pdu_info_cursor_p->sn == sn_cursor) } //end if (cursor_p != NULL) && (pdu_info_cursor_p->sn == sn_cursor)
else { else {
/* Previous PDU segment was the last one and did not have lsf indication : fill the latest gap */ /* Previous PDU segment was the last one and did not have lsf indication : fill the latest gap */
@@ -729,16 +642,13 @@ rlc_am_send_status_pdu(
control_pdu_info.nack_list[control_pdu_info.num_nack].e1 = 1; control_pdu_info.nack_list[control_pdu_info.num_nack].e1 = 1;
control_pdu_info.num_nack += 1; control_pdu_info.num_nack += 1;
nb_bits_transmitted += (RLC_AM_SN_BITS + (RLC_AM_PDU_E_BITS << 1) + (RLC_AM_STATUS_PDU_SO_LENGTH << 1)); nb_bits_transmitted += (RLC_AM_SN_BITS + (RLC_AM_PDU_E_BITS << 1) + (RLC_AM_STATUS_PDU_SO_LENGTH << 1));
#if TRACE_RLC_AM_STATUS_CREATION
LOG_D(RLC, PROTOCOL_RLC_AM_CTXT_FMT"[SEND-STATUS] LINE %d PREPARE SENDING LAST NACK %04d SO START %05d SO END %05d\n", LOG_D(RLC, PROTOCOL_RLC_AM_CTXT_FMT"[SEND-STATUS] LINE %d PREPARE SENDING LAST NACK %04d SO START %05d SO END %05d\n",
PROTOCOL_RLC_AM_CTXT_ARGS(ctxt_pP,rlc_pP), PROTOCOL_RLC_AM_CTXT_ARGS(ctxt_pP,rlc_pP),
__LINE__, __LINE__,
sn_cursor, sn_cursor,
waited_so, waited_so,
RLC_AM_STATUS_PDU_SO_END_ALL_BYTES); RLC_AM_STATUS_PDU_SO_END_ALL_BYTES);
#endif } else {
}
else {
/* Not enough resources to set a SOStart/SEnd, then set ACK_SN to current NACK_SN and stop Status PDU build */ /* Not enough resources to set a SOStart/SEnd, then set ACK_SN to current NACK_SN and stop Status PDU build */
control_pdu_info.ack_sn = sn_cursor; control_pdu_info.ack_sn = sn_cursor;
status_report_completed = true; status_report_completed = true;
@@ -765,12 +675,9 @@ rlc_am_send_status_pdu(
/* Increment sn_nack except if sn_cursor = vrMS and if current SN was not fully received */ /* Increment sn_nack except if sn_cursor = vrMS and if current SN was not fully received */
if (RLC_AM_DIFF_SN(sn_cursor,rlc_pP->vr_r) < RLC_AM_DIFF_SN(rlc_pP->vr_ms,rlc_pP->vr_r)) { if (RLC_AM_DIFF_SN(sn_cursor,rlc_pP->vr_r) < RLC_AM_DIFF_SN(rlc_pP->vr_ms,rlc_pP->vr_r)) {
sn_nack = RLC_AM_NEXT_SN(sn_cursor); sn_nack = RLC_AM_NEXT_SN(sn_cursor);
} } else {
else {
sn_nack = rlc_pP->vr_ms; sn_nack = rlc_pP->vr_ms;
} }
} // End main while NACK_SN } // End main while NACK_SN
/* Clear E1 of last nack_sn entry */ /* Clear E1 of last nack_sn entry */
@@ -786,39 +693,29 @@ rlc_am_send_status_pdu(
control_pdu_info.nack_list[control_pdu_info.num_nack - 1].e1 = 0; control_pdu_info.nack_list[control_pdu_info.num_nack - 1].e1 = 0;
} }
/* Set ACK_SN unless it was set before */ /* Set ACK_SN unless it was set before */
if (!status_report_completed) { if (!status_report_completed) {
control_pdu_info.ack_sn = sn_nack; control_pdu_info.ack_sn = sn_nack;
} }
} else { } else {
/* reception buffer empty or not enough TBS for filling at least 1 NACK_SN + E1 + E2 */ /* reception buffer empty or not enough TBS for filling at least 1 NACK_SN + E1 + E2 */
control_pdu_info.ack_sn = rlc_pP->vr_r; control_pdu_info.ack_sn = rlc_pP->vr_r;
#if TRACE_RLC_AM_STATUS_CREATION
LOG_D(RLC, PROTOCOL_RLC_AM_CTXT_FMT"[SEND-STATUS] LINE %d PREPARE SENDING ACK %04d = VR(R)\n", LOG_D(RLC, PROTOCOL_RLC_AM_CTXT_FMT"[SEND-STATUS] LINE %d PREPARE SENDING ACK %04d = VR(R)\n",
PROTOCOL_RLC_AM_CTXT_ARGS(ctxt_pP,rlc_pP), PROTOCOL_RLC_AM_CTXT_ARGS(ctxt_pP,rlc_pP),
__LINE__, __LINE__,
control_pdu_info.ack_sn); control_pdu_info.ack_sn);
#endif
} }
//msg ("[FRAME %5u][%s][RLC_AM][MOD %u/%u][RB %u] nb_bits_to_transmit %d\n", //msg ("[FRAME %5u][%s][RLC_AM][MOD %u/%u][RB %u] nb_bits_to_transmit %d\n",
// rlc_pP->module_id, rlc_pP->rb_id, ctxt_pP->frame,nb_bits_to_transmit); // rlc_pP->module_id, rlc_pP->rb_id, ctxt_pP->frame,nb_bits_to_transmit);
#if TRACE_RLC_AM_STATUS_CREATION
LOG_D(RLC, PROTOCOL_RLC_AM_CTXT_FMT"[SEND-STATUS] LINE %d PREPARE SENDING ACK %04d NUM NACK %d\n", LOG_D(RLC, PROTOCOL_RLC_AM_CTXT_FMT"[SEND-STATUS] LINE %d PREPARE SENDING ACK %04d NUM NACK %d\n",
PROTOCOL_RLC_AM_CTXT_ARGS(ctxt_pP,rlc_pP), PROTOCOL_RLC_AM_CTXT_ARGS(ctxt_pP,rlc_pP),
__LINE__, __LINE__,
control_pdu_info.ack_sn, control_pdu_info.ack_sn,
control_pdu_info.num_nack); control_pdu_info.num_nack);
#endif
/* encode the control pdu */ /* encode the control pdu */
pdu_size = (nb_bits_transmitted + 7) >> 3; pdu_size = (nb_bits_transmitted + 7) >> 3;
// AssertFatal (pdu_size <= rlc_pP->nb_bytes_requested_by_mac, "RLC AM Tx Status PDU Data size=%d bigger than remaining TBS=%d nb_bits_transmitted=%d LcId=%d\n", // AssertFatal (pdu_size <= rlc_pP->nb_bytes_requested_by_mac, "RLC AM Tx Status PDU Data size=%d bigger than remaining TBS=%d nb_bits_transmitted=%d LcId=%d\n",
// pdu_size,rlc_pP->nb_bytes_requested_by_mac,nb_bits_transmitted, rlc_pP->channel_id); // pdu_size,rlc_pP->nb_bytes_requested_by_mac,nb_bits_transmitted, rlc_pP->channel_id);
if(pdu_size > rlc_pP->nb_bytes_requested_by_mac) { if(pdu_size > rlc_pP->nb_bytes_requested_by_mac) {
@@ -827,32 +724,27 @@ rlc_am_send_status_pdu(
return; return;
} }
#if TRACE_RLC_AM_STATUS_CREATION
LOG_D(RLC, PROTOCOL_RLC_AM_CTXT_FMT"[SEND-STATUS] LINE %d forecast pdu_size %d\n", LOG_D(RLC, PROTOCOL_RLC_AM_CTXT_FMT"[SEND-STATUS] LINE %d forecast pdu_size %d\n",
PROTOCOL_RLC_AM_CTXT_ARGS(ctxt_pP,rlc_pP), PROTOCOL_RLC_AM_CTXT_ARGS(ctxt_pP,rlc_pP),
__LINE__, __LINE__,
pdu_size); pdu_size);
#endif
tb_p = get_free_mem_block(sizeof(struct mac_tb_req) + pdu_size, __func__); tb_p = get_free_mem_block(sizeof(struct mac_tb_req) + pdu_size, __func__);
if(tb_p == NULL) return; if(tb_p == NULL) return;
memset(tb_p->data, 0, sizeof(struct mac_tb_req) + pdu_size); memset(tb_p->data, 0, sizeof(struct mac_tb_req) + pdu_size);
//estimation only ((struct mac_tb_req*)(tb_p->data))->tb_size = pdu_size; //estimation only ((struct mac_tb_req*)(tb_p->data))->tb_size = pdu_size;
((struct mac_tb_req *)(tb_p->data))->data_ptr = (uint8_t *)&(tb_p->data[sizeof(struct mac_tb_req)]); ((struct mac_tb_req *)(tb_p->data))->data_ptr = (uint8_t *)&(tb_p->data[sizeof(struct mac_tb_req)]);
// warning reuse of pdu_size // warning reuse of pdu_size
// TODO : rlc_am_write_status_pdu should be rewritten as not very tested ... // TODO : rlc_am_write_status_pdu should be rewritten as not very tested ...
pdu_size = rlc_am_write_status_pdu(ctxt_pP, rlc_pP,(rlc_am_pdu_sn_10_t *)(((struct mac_tb_req *)(tb_p->data))->data_ptr), &control_pdu_info); pdu_size = rlc_am_write_status_pdu(ctxt_pP, rlc_pP,(rlc_am_pdu_sn_10_t *)(((struct mac_tb_req *)(tb_p->data))->data_ptr), &control_pdu_info);
((struct mac_tb_req *)(tb_p->data))->tb_size = pdu_size; ((struct mac_tb_req *)(tb_p->data))->tb_size = pdu_size;
//assert((((struct mac_tb_req*)(tb_p->data))->tb_size) < 3000); //assert((((struct mac_tb_req*)(tb_p->data))->tb_size) < 3000);
#if TRACE_RLC_AM_STATUS_CREATION
LOG_D(RLC, PROTOCOL_RLC_AM_CTXT_FMT"[SEND-STATUS] SEND STATUS PDU SIZE %d, rlc_pP->nb_bytes_requested_by_mac %d, nb_bits_to_transmit>>3 %d\n", LOG_D(RLC, PROTOCOL_RLC_AM_CTXT_FMT"[SEND-STATUS] SEND STATUS PDU SIZE %d, rlc_pP->nb_bytes_requested_by_mac %d, nb_bits_to_transmit>>3 %d\n",
PROTOCOL_RLC_AM_CTXT_ARGS(ctxt_pP,rlc_pP), PROTOCOL_RLC_AM_CTXT_ARGS(ctxt_pP,rlc_pP),
pdu_size, pdu_size,
rlc_pP->nb_bytes_requested_by_mac, rlc_pP->nb_bytes_requested_by_mac,
nb_bits_to_transmit >> 3); nb_bits_to_transmit >> 3);
#endif
// AssertFatal (pdu_size == ((nb_bits_transmitted + 7) >> 3), "RLC AM Tx Status PDU Data encoding size=%d different than expected=%d LcId=%d\n", // AssertFatal (pdu_size == ((nb_bits_transmitted + 7) >> 3), "RLC AM Tx Status PDU Data encoding size=%d different than expected=%d LcId=%d\n",
// pdu_size,((nb_bits_transmitted + 7) >> 3), rlc_pP->channel_id); // pdu_size,((nb_bits_transmitted + 7) >> 3), rlc_pP->channel_id);
@@ -869,7 +761,6 @@ rlc_am_send_status_pdu(
list_add_head(tb_p, &rlc_pP->control_pdu_list); list_add_head(tb_p, &rlc_pP->control_pdu_list);
rlc_pP->stat_tx_control_pdu += 1; rlc_pP->stat_tx_control_pdu += 1;
rlc_pP->stat_tx_control_bytes += pdu_size; rlc_pP->stat_tx_control_bytes += pdu_size;
} }
openair2/LAYER2/RLC/UM_v9.3.0/rlc_um.c
+47 -167
View File
@@ -59,8 +59,7 @@ void rlc_um_stat_req (rlc_um_entity_t *rlc_pP,
unsigned int *stat_rx_data_bytes_dropped, unsigned int *stat_rx_data_bytes_dropped,
unsigned int *stat_rx_data_pdu_out_of_window, unsigned int *stat_rx_data_pdu_out_of_window,
unsigned int *stat_rx_data_bytes_out_of_window, unsigned int *stat_rx_data_bytes_out_of_window,
unsigned int* stat_timer_reordering_timed_out) unsigned int *stat_timer_reordering_timed_out) {
{
*stat_tx_pdcp_sdu = rlc_pP->stat_tx_pdcp_sdu; *stat_tx_pdcp_sdu = rlc_pP->stat_tx_pdcp_sdu;
*stat_tx_pdcp_bytes = rlc_pP->stat_tx_pdcp_bytes; *stat_tx_pdcp_bytes = rlc_pP->stat_tx_pdcp_bytes;
*stat_tx_pdcp_sdu_discarded = rlc_pP->stat_tx_pdcp_sdu_discarded; *stat_tx_pdcp_sdu_discarded = rlc_pP->stat_tx_pdcp_sdu_discarded;
@@ -81,8 +80,7 @@ void rlc_um_stat_req (rlc_um_entity_t *rlc_pP,
} }
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
uint32_t uint32_t
rlc_um_get_buffer_occupancy (rlc_um_entity_t *rlc_pP) rlc_um_get_buffer_occupancy (rlc_um_entity_t *rlc_pP) {
{
if (rlc_pP->buffer_occupancy > 0) { if (rlc_pP->buffer_occupancy > 0) {
return rlc_pP->buffer_occupancy; return rlc_pP->buffer_occupancy;
} else { } else {
@@ -91,12 +89,10 @@ rlc_um_get_buffer_occupancy (rlc_um_entity_t *rlc_pP)
} }
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
void void
rlc_um_get_pdus (const protocol_ctxt_t* const ctxt_pP, void *argP) rlc_um_get_pdus (const protocol_ctxt_t *const ctxt_pP, void *argP) {
{
rlc_um_entity_t *rlc_p = (rlc_um_entity_t *) argP; rlc_um_entity_t *rlc_p = (rlc_um_entity_t *) argP;
switch (rlc_p->protocol_state) { switch (rlc_p->protocol_state) {
case RLC_NULL_STATE: case RLC_NULL_STATE:
// from 3GPP TS 25.322 V9.2.0 p43 // from 3GPP TS 25.322 V9.2.0 p43
// In the NULL state the RLC entity does not exist and therefore it is // In the NULL state the RLC entity does not exist and therefore it is
@@ -153,7 +149,6 @@ rlc_um_get_pdus (const protocol_ctxt_t* const ctxt_pP, void *argP)
// - stays in the LOCAL_SUSPEND state; // - stays in the LOCAL_SUSPEND state;
// - modifies only the protocol parameters and timers as indicated by // - modifies only the protocol parameters and timers as indicated by
// upper layers. // upper layers.
// TO DO TAKE CARE OF SN : THE IMPLEMENTATION OF THIS FUNCTIONNALITY IS NOT CRITICAL // TO DO TAKE CARE OF SN : THE IMPLEMENTATION OF THIS FUNCTIONNALITY IS NOT CRITICAL
break; break;
@@ -166,26 +161,17 @@ rlc_um_get_pdus (const protocol_ctxt_t* const ctxt_pP, void *argP)
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
void void
rlc_um_rx (const protocol_ctxt_t* const ctxt_pP, void *argP, struct mac_data_ind data_indP) rlc_um_rx (const protocol_ctxt_t *const ctxt_pP, void *argP, struct mac_data_ind data_indP) {
{
rlc_um_entity_t *l_rlc_p = (rlc_um_entity_t *) argP; rlc_um_entity_t *l_rlc_p = (rlc_um_entity_t *) argP;
#if TRACE_RLC_UM_PDU || MESSAGE_CHART_GENERATOR
char message_string[10000]; char message_string[10000];
mem_block_t *tb_p; mem_block_t *tb_p;
int16_t tb_size_in_bytes; int16_t tb_size_in_bytes;
size_t message_string_size = 0; size_t message_string_size = 0;
rlc_um_pdu_info_t pdu_info; rlc_um_pdu_info_t pdu_info;
int index; int index;
#endif
#if TRACE_RLC_UM_PDU
int octet_index; int octet_index;
# if ENABLE_ITTI
MessageDef *msg_p;
# endif
#endif
switch (l_rlc_p->protocol_state) { switch (l_rlc_p->protocol_state) {
case RLC_NULL_STATE: case RLC_NULL_STATE:
// from 3GPP TS 25.322 V9.2.0 p43 // from 3GPP TS 25.322 V9.2.0 p43
// In the NULL state the RLC entity does not exist and therefore it is // In the NULL state the RLC entity does not exist and therefore it is
@@ -196,9 +182,8 @@ rlc_um_rx (const protocol_ctxt_t* const ctxt_pP, void *argP, struct mac_data_ind
// - enters the DATA_TRANSFER_READY state. // - enters the DATA_TRANSFER_READY state.
LOG_I(RLC, PROTOCOL_RLC_UM_CTXT_FMT" ERROR MAC_DATA_IND IN RLC_NULL_STATE\n", LOG_I(RLC, PROTOCOL_RLC_UM_CTXT_FMT" ERROR MAC_DATA_IND IN RLC_NULL_STATE\n",
PROTOCOL_RLC_UM_CTXT_ARGS(ctxt_pP,l_rlc_p)); PROTOCOL_RLC_UM_CTXT_ARGS(ctxt_pP,l_rlc_p));
#if MESSAGE_CHART_GENERATOR
if (data_indP.data.nb_elements > 0) { if (data_indP.data.nb_elements > 0 && MESSAGE_CHART_GENERATOR) {
tb_p = data_indP.data.head; tb_p = data_indP.data.head;
while (tb_p != NULL) { while (tb_p != NULL) {
@@ -227,12 +212,10 @@ rlc_um_rx (const protocol_ctxt_t* const ctxt_pP, void *argP, struct mac_data_ind
(const char *)pdu_info.payload, (const char *)pdu_info.payload,
tb_size_in_bytes, tb_size_in_bytes,
message_string); message_string);
tb_p = tb_p->next; tb_p = tb_p->next;
} }
} }/*MESSAGE_CHART_GENERATOR*/
#endif
list_free (&data_indP.data); list_free (&data_indP.data);
break; break;
@@ -254,13 +237,10 @@ rlc_um_rx (const protocol_ctxt_t* const ctxt_pP, void *argP, struct mac_data_ind
// - enters the LOCAL_SUSPEND state. // - enters the LOCAL_SUSPEND state.
data_indP.tb_size = data_indP.tb_size >> 3; data_indP.tb_size = data_indP.tb_size >> 3;
#if TRACE_RLC_UM_PDU || MESSAGE_CHART_GENERATOR if (data_indP.data.nb_elements > 0 && (MESSAGE_CHART_GENERATOR || LOG_DEBUGFLAG(DEBUG_RLC))) {
if (data_indP.data.nb_elements > 0) {
LOG_D(RLC, PROTOCOL_RLC_UM_CTXT_FMT" MAC_DATA_IND %d TBs\n", LOG_D(RLC, PROTOCOL_RLC_UM_CTXT_FMT" MAC_DATA_IND %d TBs\n",
PROTOCOL_RLC_UM_CTXT_ARGS(ctxt_pP,l_rlc_p), PROTOCOL_RLC_UM_CTXT_ARGS(ctxt_pP,l_rlc_p),
data_indP.data.nb_elements); data_indP.data.nb_elements);
tb_p = data_indP.data.head; tb_p = data_indP.data.head;
while (tb_p != NULL) { while (tb_p != NULL) {
@@ -271,7 +251,7 @@ rlc_um_rx (const protocol_ctxt_t* const ctxt_pP, void *argP, struct mac_data_ind
&pdu_info, &pdu_info,
l_rlc_p->rx_sn_length); l_rlc_p->rx_sn_length);
#if MESSAGE_CHART_GENERATOR if (MESSAGE_CHART_GENERATOR) {
message_string_size = 0; message_string_size = 0;
message_string_size += sprintf(&message_string[message_string_size], message_string_size += sprintf(&message_string[message_string_size],
MSC_AS_TIME_FMT" "PROTOCOL_RLC_UM_MSC_FMT"DATA SN %u size %u FI %u", MSC_AS_TIME_FMT" "PROTOCOL_RLC_UM_MSC_FMT"DATA SN %u size %u FI %u",
@@ -295,16 +275,15 @@ rlc_um_rx (const protocol_ctxt_t* const ctxt_pP, void *argP, struct mac_data_ind
(char *)pdu_info.payload, (char *)pdu_info.payload,
tb_size_in_bytes, tb_size_in_bytes,
message_string); message_string);
}
#endif if (LOG_DEBUGFLAG(DEBUG_RLC)) {
#if TRACE_RLC_UM_PDU
message_string_size = 0; message_string_size = 0;
message_string_size += sprintf(&message_string[message_string_size], "Bearer : %u\n", l_rlc_p->rb_id); message_string_size += sprintf(&message_string[message_string_size], "Bearer : %u\n", l_rlc_p->rb_id);
message_string_size += sprintf(&message_string[message_string_size], "PDU size : %u\n", tb_size_in_bytes); message_string_size += sprintf(&message_string[message_string_size], "PDU size : %u\n", tb_size_in_bytes);
message_string_size += sprintf(&message_string[message_string_size], "Header size : %u\n", pdu_info.header_size); message_string_size += sprintf(&message_string[message_string_size], "Header size : %u\n", pdu_info.header_size);
message_string_size += sprintf(&message_string[message_string_size], "Payload size: %u\n", pdu_info.payload_size); message_string_size += sprintf(&message_string[message_string_size], "Payload size: %u\n", pdu_info.payload_size);
message_string_size += sprintf(&message_string[message_string_size], "PDU type : RLC UM DATA IND: UMD PDU\n\n"); message_string_size += sprintf(&message_string[message_string_size], "PDU type : RLC UM DATA IND: UMD PDU\n\n");
message_string_size += sprintf(&message_string[message_string_size], "Header :\n"); message_string_size += sprintf(&message_string[message_string_size], "Header :\n");
message_string_size += sprintf(&message_string[message_string_size], " FI : %u\n", pdu_info.fi); message_string_size += sprintf(&message_string[message_string_size], " FI : %u\n", pdu_info.fi);
message_string_size += sprintf(&message_string[message_string_size], " E : %u\n", pdu_info.e); message_string_size += sprintf(&message_string[message_string_size], " E : %u\n", pdu_info.e);
@@ -349,24 +328,13 @@ rlc_um_rx (const protocol_ctxt_t* const ctxt_pP, void *argP, struct mac_data_ind
} }
message_string_size += sprintf(&message_string[message_string_size], " |\n"); message_string_size += sprintf(&message_string[message_string_size], " |\n");
LOG_UI(RLC, "%s|\n", message_string);
# if ENABLE_ITTI }
msg_p = itti_alloc_new_message_sized (ctxt_pP->enb_flag ? TASK_RLC_ENB:TASK_RLC_UE , RLC_UM_DATA_PDU_IND, message_string_size + sizeof (IttiMsgText));
msg_p->ittiMsg.rlc_um_data_pdu_ind.size = message_string_size;
memcpy(&msg_p->ittiMsg.rlc_um_data_pdu_ind.text, message_string, message_string_size);
itti_send_msg_to_task(TASK_UNKNOWN, ctxt_pP->instance, msg_p);
# else
LOG_T(RLC, "%s", message_string);
# endif // ENABLE_ITTI
#endif // TRACE_RLC_UM_PDU
tb_p = tb_p->next; tb_p = tb_p->next;
} }
} }
#endif
rlc_um_receive (ctxt_pP, l_rlc_p, data_indP); rlc_um_receive (ctxt_pP, l_rlc_p, data_indP);
break; break;
@@ -389,31 +357,6 @@ rlc_um_rx (const protocol_ctxt_t* const ctxt_pP, void *argP, struct mac_data_ind
// upper layers. // upper layers.
LOG_I(RLC, PROTOCOL_RLC_UM_CTXT_FMT" RLC_LOCAL_SUSPEND_STATE\n", LOG_I(RLC, PROTOCOL_RLC_UM_CTXT_FMT" RLC_LOCAL_SUSPEND_STATE\n",
PROTOCOL_RLC_UM_CTXT_ARGS(ctxt_pP,l_rlc_p)); PROTOCOL_RLC_UM_CTXT_ARGS(ctxt_pP,l_rlc_p));
/*if (data_indP.data.nb_elements > 0) {
LOG_D(RLC, "[FRAME %05d][%s][RLC_UM][MOD %02u/%02u][RB %02d] MAC_DATA_IND %d TBs\n", l_rlc_p->module_id, l_rlc_p->rb_id, ctxt_pP->frame, data_indP.data.nb_elements);
rlc_p[l_rlc_p->module_id].m_mscgen_trace_length = sprintf(rlc_p[l_rlc_p->module_id].m_mscgen_trace, "[MSC_MSG][FRAME %05d][MAC_%s][MOD %02d][][--- MAC_DATA_IND/ %d TB(s) ",
ctxt_pP->frame,
(ctxt_pP->enb_flag) ? "eNB":"UE",
l_rlc_p->module_id,
data_indP.data.nb_elements);
tb = data_indP.data.head;
while (tb != NULL) {
rlc_p[l_rlc_p->module_id].m_mscgen_trace_length += sprintf(&rlc_p[l_rlc_p->module_id].m_mscgen_trace[rlc_p[l_rlc_p->module_id].m_mscgen_trace_length], " SN %d %c%c%c %d Bytes ",
(((struct mac_tb_ind *) (tb->data))->data_ptr[1]) + (((uint16_t)((((struct mac_tb_ind *) (tb->data))->data_ptr[0]) & 0x03)) << 8),
(((struct mac_tb_ind *) (tb->data))->data_ptr[0] & 0x10) ? '}':'{',
(((struct mac_tb_ind *) (tb->data))->data_ptr[0] & 0x08) ? '{':'}',
(((struct mac_tb_ind *) (tb->data))->data_ptr[0] & 0x04) ? 'E':'_',
((struct mac_tb_ind *) (tb->data))->size);
tb = tb->next;
}
rlc_p[l_rlc_p->module_id].m_mscgen_trace_length += sprintf(&rlc_p[l_rlc_p->module_id].m_mscgen_trace[rlc_p[l_rlc_p->module_id].m_mscgen_trace_length], " DROPPED RLC LOCAL SUSPEND STATE ---X][RLC_UM][MOD %02d][RB %02d]\n",
l_rlc_p->module_id,
l_rlc_p->rb_id);
rlc_p[l_rlc_p->module_id].m_mscgen_trace[rlc_p[l_rlc_p->module_id].m_mscgen_trace_length] = 0;
LOG_D(RLC, "%s", rlc_p[l_rlc_p->module_id].m_mscgen_trace);
}*/
list_free (&data_indP.data); list_free (&data_indP.data);
break; break;
@@ -427,15 +370,13 @@ rlc_um_rx (const protocol_ctxt_t* const ctxt_pP, void *argP, struct mac_data_ind
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
struct mac_status_resp struct mac_status_resp
rlc_um_mac_status_indication (const protocol_ctxt_t* const ctxt_pP, void *rlc_pP, uint16_t tbs_sizeP, struct mac_status_ind tx_statusP,const eNB_flag_t enb_flagP) rlc_um_mac_status_indication (const protocol_ctxt_t *const ctxt_pP, void *rlc_pP, uint16_t tbs_sizeP, struct mac_status_ind tx_statusP,const eNB_flag_t enb_flagP) {
{
struct mac_status_resp status_resp; struct mac_status_resp status_resp;
uint16_t sdu_size = 0; uint16_t sdu_size = 0;
uint16_t sdu_remaining_size = 0; uint16_t sdu_remaining_size = 0;
int32_t diff_time=0; int32_t diff_time=0;
rlc_um_entity_t *rlc_p = NULL; rlc_um_entity_t *rlc_p = (rlc_um_entity_t *) rlc_pP;
mem_block_t *mb_p = NULL; mem_block_t *mb_p = NULL;
status_resp.buffer_occupancy_in_pdus = 0; status_resp.buffer_occupancy_in_pdus = 0;
status_resp.buffer_occupancy_in_bytes = 0; status_resp.buffer_occupancy_in_bytes = 0;
status_resp.head_sdu_remaining_size_to_send = 0; status_resp.head_sdu_remaining_size_to_send = 0;
@@ -443,31 +384,24 @@ rlc_um_mac_status_indication (const protocol_ctxt_t* const ctxt_pP, void *rlc_pP
status_resp.head_sdu_is_segmented = 0; status_resp.head_sdu_is_segmented = 0;
if (rlc_pP) { if (rlc_pP) {
rlc_p = (rlc_um_entity_t *) rlc_pP;
status_resp.rlc_info.rlc_protocol_state = rlc_p->protocol_state; status_resp.rlc_info.rlc_protocol_state = rlc_p->protocol_state;
rlc_um_check_timer_dar_time_out(ctxt_pP, rlc_p); rlc_um_check_timer_dar_time_out(ctxt_pP, rlc_p);
rlc_p->nb_bytes_requested_by_mac = tbs_sizeP; rlc_p->nb_bytes_requested_by_mac = tbs_sizeP;
status_resp.buffer_occupancy_in_bytes = rlc_um_get_buffer_occupancy (rlc_p); status_resp.buffer_occupancy_in_bytes = rlc_um_get_buffer_occupancy (rlc_p);
if ((status_resp.buffer_occupancy_in_bytes > 0) && ((mb_p = list_get_head(&rlc_p->input_sdus)) != NULL)) { if ((status_resp.buffer_occupancy_in_bytes > 0) && ((mb_p = list_get_head(&rlc_p->input_sdus)) != NULL)) {
if (enb_flagP == ENB_FLAG_YES) { if (enb_flagP == ENB_FLAG_YES) {
/* For eNB: add minimum RLC UM header size for the scheduler */ /* For eNB: add minimum RLC UM header size for the scheduler */
/* For UE : RLC header part is not taken into account for BSR reporting (cf 36.321) */ /* For UE : RLC header part is not taken into account for BSR reporting (cf 36.321) */
status_resp.buffer_occupancy_in_bytes += rlc_p->tx_header_min_length_in_bytes; status_resp.buffer_occupancy_in_bytes += rlc_p->tx_header_min_length_in_bytes;
} }
status_resp.buffer_occupancy_in_pdus = rlc_p->input_sdus.nb_elements;
status_resp.buffer_occupancy_in_pdus = rlc_p->input_sdus.nb_elements;
diff_time = ctxt_pP->frame - ((struct rlc_um_tx_sdu_management *)mb_p->data)->sdu_creation_time; diff_time = ctxt_pP->frame - ((struct rlc_um_tx_sdu_management *)mb_p->data)->sdu_creation_time;
status_resp.head_sdu_creation_time = (diff_time > 0 ) ? (uint32_t) diff_time : (uint32_t)(0xffffffff - diff_time + ctxt_pP->frame) ; status_resp.head_sdu_creation_time = (diff_time > 0 ) ? (uint32_t) diff_time : (uint32_t)(0xffffffff - diff_time + ctxt_pP->frame) ;
//msg("rlc_p status for ctxt_pP->frame %d diff time %d resp %d\n", ctxt_pP->frame, diff_time,status_resp.head_sdu_creation_time) ; //msg("rlc_p status for ctxt_pP->frame %d diff time %d resp %d\n", ctxt_pP->frame, diff_time,status_resp.head_sdu_creation_time) ;
sdu_size = ((struct rlc_um_tx_sdu_management *) mb_p->data)->sdu_size; sdu_size = ((struct rlc_um_tx_sdu_management *) mb_p->data)->sdu_size;
sdu_remaining_size = ((struct rlc_um_tx_sdu_management *) mb_p->data)->sdu_remaining_size; sdu_remaining_size = ((struct rlc_um_tx_sdu_management *) mb_p->data)->sdu_remaining_size;
status_resp.head_sdu_remaining_size_to_send = sdu_remaining_size; status_resp.head_sdu_remaining_size_to_send = sdu_remaining_size;
if (sdu_size == sdu_remaining_size) { if (sdu_size == sdu_remaining_size) {
@@ -475,35 +409,31 @@ rlc_um_mac_status_indication (const protocol_ctxt_t* const ctxt_pP, void *rlc_pP
} else { } else {
status_resp.head_sdu_is_segmented = 1; status_resp.head_sdu_is_segmented = 1;
} }
} else { } else {
} }
//msg("[FRAME %05d][%s][RLC_UM][MOD %02u/%02u][RB %02d] MAC_STATUS_INDICATION BO = %d\n", ((rlc_um_entity_t *) rlc_pP)->module_id, ((rlc_um_entity_t *) rlc_pP)->rb_id, status_resp.buffer_occupancy_in_bytes); status_resp.rlc_info.rlc_protocol_state = rlc_p->protocol_state;
status_resp.rlc_info.rlc_protocol_state = ((rlc_um_entity_t *) rlc_pP)->protocol_state; if (LOG_DEBUGFLAG(DEBUG_RLC)) {
#if TRACE_RLC_UM_TX_STATUS if (( rlc_p->rb_id > 0) && (status_resp.buffer_occupancy_in_bytes > 0)) {
LOG_UI(RLC, PROTOCOL_RLC_UM_CTXT_FMT"MAC_STATUS_INDICATION (DATA) %d bytes requested -> %d bytes available\n",
if ((((rlc_um_entity_t *) rlc_pP)->rb_id > 0) && (status_resp.buffer_occupancy_in_bytes > 0)) { PROTOCOL_RLC_UM_CTXT_ARGS(ctxt_pP,rlc_p),
LOG_D(RLC, PROTOCOL_RLC_UM_CTXT_FMT" MAC_STATUS_INDICATION (DATA) %d bytes requested -> %d bytes available\n",
PROTOCOL_RLC_UM_CTXT_ARGS(ctxt_pP,rlc_pP),
tbs_sizeP, tbs_sizeP,
status_resp.buffer_occupancy_in_bytes); status_resp.buffer_occupancy_in_bytes);
if ((tx_statusP.tx_status == MAC_TX_STATUS_SUCCESSFUL) && (tx_statusP.no_pdu)) { if ((tx_statusP.tx_status == MAC_TX_STATUS_SUCCESSFUL) && (tx_statusP.no_pdu)) {
LOG_D(RLC, PROTOCOL_RLC_UM_CTXT_FMT" MAC_STATUS_INDICATION TX STATUS SUCCESSFUL %d PDUs\n", LOG_D(RLC, PROTOCOL_RLC_UM_CTXT_FMT" MAC_STATUS_INDICATION TX STATUS SUCCESSFUL %d PDUs\n",
PROTOCOL_RLC_UM_CTXT_ARGS(ctxt_pP,rlc_pP), PROTOCOL_RLC_UM_CTXT_ARGS(ctxt_pP,rlc_p),
tx_statusP.no_pdu); tx_statusP.no_pdu);
} }
if ((tx_statusP.tx_status == MAC_TX_STATUS_UNSUCCESSFUL) && (tx_statusP.no_pdu)) { if ((tx_statusP.tx_status == MAC_TX_STATUS_UNSUCCESSFUL) && (tx_statusP.no_pdu)) {
LOG_D(RLC, PROTOCOL_RLC_UM_CTXT_FMT" MAC_STATUS_INDICATION TX STATUS UNSUCCESSFUL %d PDUs\n", LOG_UI(RLC, PROTOCOL_RLC_UM_CTXT_FMT" MAC_STATUS_INDICATION TX STATUS UNSUCCESSFUL %d PDUs\n",
PROTOCOL_RLC_UM_CTXT_ARGS(ctxt_pP,rlc_pP), PROTOCOL_RLC_UM_CTXT_ARGS(ctxt_pP,rlc_p),
tx_statusP.no_pdu); tx_statusP.no_pdu);
} }
} }
}
#endif
} else { } else {
LOG_E(RLC, "[RLC] rlc_um_mac_status_indication RLC NULL!!!\n"); LOG_E(RLC, "[RLC] rlc_um_mac_status_indication RLC NULL!!!\n");
} }
@@ -516,35 +446,25 @@ void
rlc_um_set_nb_bytes_requested_by_mac ( rlc_um_set_nb_bytes_requested_by_mac (
void *rlc_pP, void *rlc_pP,
const tb_size_t tb_sizeP const tb_size_t tb_sizeP
) ) {
{
((rlc_um_entity_t *) rlc_pP)->nb_bytes_requested_by_mac = tb_sizeP; ((rlc_um_entity_t *) rlc_pP)->nb_bytes_requested_by_mac = tb_sizeP;
} }
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
struct mac_data_req struct mac_data_req
rlc_um_mac_data_request (const protocol_ctxt_t* const ctxt_pP, void *rlc_pP,const eNB_flag_t enb_flagP) rlc_um_mac_data_request (const protocol_ctxt_t *const ctxt_pP, void *rlc_pP,const eNB_flag_t enb_flagP) {
{
struct mac_data_req data_req; struct mac_data_req data_req;
int16_t tb_size_in_bytes; int16_t tb_size_in_bytes;
mem_block_t *tb_p; mem_block_t *tb_p;
#if TRACE_RLC_UM_PDU || MESSAGE_CHART_GENERATOR
char message_string[10000]; char message_string[10000];
size_t message_string_size = 0; size_t message_string_size = 0;
# if ENABLE_ITTI
MessageDef *msg_p;
# endif
rlc_um_pdu_info_t pdu_info; rlc_um_pdu_info_t pdu_info;
int octet_index, index; int octet_index, index;
#endif
rlc_um_entity_t *l_rlc_p = (rlc_um_entity_t *) rlc_pP; rlc_um_entity_t *l_rlc_p = (rlc_um_entity_t *) rlc_pP;
rlc_um_get_pdus(ctxt_pP, l_rlc_p); rlc_um_get_pdus(ctxt_pP, l_rlc_p);
list_init (&data_req.data, NULL); list_init (&data_req.data, NULL);
list_add_list (&l_rlc_p->pdus_to_mac_layer, &data_req.data); list_add_list (&l_rlc_p->pdus_to_mac_layer, &data_req.data);
if (enb_flagP) { if (enb_flagP) {
// redundant in UE MAC Tx processing and not used in eNB scheduler ... // redundant in UE MAC Tx processing and not used in eNB scheduler ...
data_req.buffer_occupancy_in_bytes = rlc_um_get_buffer_occupancy (l_rlc_p); data_req.buffer_occupancy_in_bytes = rlc_um_get_buffer_occupancy (l_rlc_p);
@@ -561,7 +481,6 @@ rlc_um_mac_data_request (const protocol_ctxt_t* const ctxt_pP, void *rlc_pP,cons
while (tb_p != NULL) { while (tb_p != NULL) {
tb_size_in_bytes = ((struct mac_tb_req *) (tb_p->data))->tb_size; tb_size_in_bytes = ((struct mac_tb_req *) (tb_p->data))->tb_size;
LOG_D(RLC, PROTOCOL_RLC_UM_CTXT_FMT" MAC_DATA_REQUEST TB SIZE %u\n", LOG_D(RLC, PROTOCOL_RLC_UM_CTXT_FMT" MAC_DATA_REQUEST TB SIZE %u\n",
PROTOCOL_RLC_UM_CTXT_ARGS(ctxt_pP,l_rlc_p), PROTOCOL_RLC_UM_CTXT_ARGS(ctxt_pP,l_rlc_p),
((struct mac_tb_req *) (tb_p->data))->tb_size); ((struct mac_tb_req *) (tb_p->data))->tb_size);
@@ -575,10 +494,10 @@ rlc_um_mac_data_request (const protocol_ctxt_t* const ctxt_pP, void *rlc_pP,cons
continue; continue;
} }
#if TRACE_RLC_UM_PDU || MESSAGE_CHART_GENERATOR if (MESSAGE_CHART_GENERATOR || LOG_DEBUGFLAG(DEBUG_RLC) ) {
rlc_um_get_pdu_infos(ctxt_pP, l_rlc_p,(rlc_um_pdu_sn_10_t *) ((struct mac_tb_req *) (tb_p->data))->data_ptr, tb_size_in_bytes, &pdu_info, l_rlc_p->rx_sn_length); rlc_um_get_pdu_infos(ctxt_pP, l_rlc_p,(rlc_um_pdu_sn_10_t *) ((struct mac_tb_req *) (tb_p->data))->data_ptr, tb_size_in_bytes, &pdu_info, l_rlc_p->rx_sn_length);
#endif
#if MESSAGE_CHART_GENERATOR if(MESSAGE_CHART_GENERATOR) {
message_string_size = 0; message_string_size = 0;
message_string_size += sprintf(&message_string[message_string_size], message_string_size += sprintf(&message_string[message_string_size],
MSC_AS_TIME_FMT" "PROTOCOL_RLC_UM_MSC_FMT" DATA SN %u size %u FI %u", MSC_AS_TIME_FMT" "PROTOCOL_RLC_UM_MSC_FMT" DATA SN %u size %u FI %u",
@@ -602,16 +521,15 @@ rlc_um_mac_data_request (const protocol_ctxt_t* const ctxt_pP, void *rlc_pP,cons
(const char *)pdu_info.payload, (const char *)pdu_info.payload,
pdu_info.payload_size, pdu_info.payload_size,
message_string); message_string);
}
#endif if(LOG_DEBUGFLAG(DEBUG_RLC)) {
#if TRACE_RLC_UM_PDU
message_string_size = 0; message_string_size = 0;
message_string_size += sprintf(&message_string[message_string_size], "Bearer : %u\n", l_rlc_p->rb_id); message_string_size += sprintf(&message_string[message_string_size], "Bearer : %u\n", l_rlc_p->rb_id);
message_string_size += sprintf(&message_string[message_string_size], "PDU size : %u\n", tb_size_in_bytes); message_string_size += sprintf(&message_string[message_string_size], "PDU size : %u\n", tb_size_in_bytes);
message_string_size += sprintf(&message_string[message_string_size], "Header size : %u\n", pdu_info.header_size); message_string_size += sprintf(&message_string[message_string_size], "Header size : %u\n", pdu_info.header_size);
message_string_size += sprintf(&message_string[message_string_size], "Payload size: %u\n", pdu_info.payload_size); message_string_size += sprintf(&message_string[message_string_size], "Payload size: %u\n", pdu_info.payload_size);
message_string_size += sprintf(&message_string[message_string_size], "PDU type : RLC UM DATA IND: UMD PDU\n\n"); message_string_size += sprintf(&message_string[message_string_size], "PDU type : RLC UM DATA IND: UMD PDU\n\n");
message_string_size += sprintf(&message_string[message_string_size], "Header :\n"); message_string_size += sprintf(&message_string[message_string_size], "Header :\n");
message_string_size += sprintf(&message_string[message_string_size], " FI : %u\n", pdu_info.fi); message_string_size += sprintf(&message_string[message_string_size], " FI : %u\n", pdu_info.fi);
message_string_size += sprintf(&message_string[message_string_size], " E : %u\n", pdu_info.e); message_string_size += sprintf(&message_string[message_string_size], " E : %u\n", pdu_info.e);
@@ -656,61 +574,38 @@ rlc_um_mac_data_request (const protocol_ctxt_t* const ctxt_pP, void *rlc_pP,cons
} }
message_string_size += sprintf(&message_string[message_string_size], " |\n"); message_string_size += sprintf(&message_string[message_string_size], " |\n");
LOG_UI(RLC, "%s\n", message_string);
} /*LOG_DEBUGFLAG(DEBUG_RLC) */
} /* MESSAGE_CHART_GENERATOR || LOG_DEBUGFLAG(DEBUG_RLC) */
# if ENABLE_ITTI
msg_p = itti_alloc_new_message_sized (ctxt_pP->enb_flag > 0 ? TASK_RLC_ENB:TASK_RLC_UE , RLC_UM_DATA_PDU_REQ, message_string_size + sizeof (IttiMsgText));
msg_p->ittiMsg.rlc_um_data_pdu_req.size = message_string_size;
memcpy(&msg_p->ittiMsg.rlc_um_data_pdu_req.text, message_string, message_string_size);
itti_send_msg_to_task(TASK_UNKNOWN, ctxt_pP->instance, msg_p);
# else
LOG_T(RLC, "%s", message_string);
# endif
#endif
tb_p = tb_p->next; tb_p = tb_p->next;
} } /* while (tb_p != NULL) */
} } /* if (data_req.data.nb_elements > 0) */
return data_req; return data_req;
} }
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
void void
rlc_um_mac_data_indication (const protocol_ctxt_t* const ctxt_pP, void *rlc_pP, struct mac_data_ind data_indP) rlc_um_mac_data_indication (const protocol_ctxt_t *const ctxt_pP, void *rlc_pP, struct mac_data_ind data_indP) {
{
rlc_um_rx (ctxt_pP, rlc_pP, data_indP); rlc_um_rx (ctxt_pP, rlc_pP, data_indP);
rlc_um_check_timer_dar_time_out(ctxt_pP, rlc_pP); rlc_um_check_timer_dar_time_out(ctxt_pP, rlc_pP);
} }
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
void void
rlc_um_data_req (const protocol_ctxt_t* const ctxt_pP, void *rlc_pP, mem_block_t *sdu_pP) rlc_um_data_req (const protocol_ctxt_t *const ctxt_pP, void *rlc_pP, mem_block_t *sdu_pP) {
{
rlc_um_entity_t *rlc_p = (rlc_um_entity_t *) rlc_pP; rlc_um_entity_t *rlc_p = (rlc_um_entity_t *) rlc_pP;
#if TRACE_RLC_UM_PDU
#if ENABLE_ITTI
MessageDef *msg_p;
# endif
uint16_t data_offset; uint16_t data_offset;
uint16_t data_size; uint16_t data_size;
size_t message_string_size = 0; size_t message_string_size = 0;
int octet_index, index; int octet_index, index;
char message_string[7000]; char message_string[7000];
#endif
LOG_D(RLC, PROTOCOL_RLC_UM_CTXT_FMT" RLC_UM_DATA_REQ size %d Bytes, BO %d , NB SDU %d\n", LOG_D(RLC, PROTOCOL_RLC_UM_CTXT_FMT" RLC_UM_DATA_REQ size %d Bytes, BO %d , NB SDU %d\n",
PROTOCOL_RLC_UM_CTXT_ARGS(ctxt_pP,rlc_p), PROTOCOL_RLC_UM_CTXT_ARGS(ctxt_pP,rlc_p),
((struct rlc_um_data_req *) (sdu_pP->data))->data_size, ((struct rlc_um_data_req *) (sdu_pP->data))->data_size,
rlc_p->buffer_occupancy, rlc_p->buffer_occupancy,
rlc_p->input_sdus.nb_elements); rlc_p->input_sdus.nb_elements);
/*rlc_util_print_hex_octets(
RLC,
(uint8_t*)&sdu_pP->data[sizeof (struct rlc_um_data_req_alloc)],
((struct rlc_um_data_req *) (sdu_pP->data))->data_size);*/
// IMPORTANT : do not change order of affectations // IMPORTANT : do not change order of affectations
((struct rlc_um_tx_sdu_management *) (sdu_pP->data))->sdu_size = ((struct rlc_um_data_req *) (sdu_pP->data))->data_size; ((struct rlc_um_tx_sdu_management *) (sdu_pP->data))->sdu_size = ((struct rlc_um_data_req *) (sdu_pP->data))->data_size;
//rlc_p->nb_sdu += 1; //rlc_p->nb_sdu += 1;
@@ -720,10 +615,8 @@ rlc_um_data_req (const protocol_ctxt_t* const ctxt_pP, void *rlc_pP, mem_block_t
((struct rlc_um_tx_sdu_management *) (sdu_pP->data))->sdu_segmented_size = 0; ((struct rlc_um_tx_sdu_management *) (sdu_pP->data))->sdu_segmented_size = 0;
((struct rlc_um_tx_sdu_management *) (sdu_pP->data))->sdu_creation_time = ctxt_pP->frame; ((struct rlc_um_tx_sdu_management *) (sdu_pP->data))->sdu_creation_time = ctxt_pP->frame;
//rlc_p->next_sdu_index = (rlc_p->next_sdu_index + 1) % rlc_p->size_input_sdus_buffer; //rlc_p->next_sdu_index = (rlc_p->next_sdu_index + 1) % rlc_p->size_input_sdus_buffer;
rlc_p->stat_tx_pdcp_sdu += 1; rlc_p->stat_tx_pdcp_sdu += 1;
rlc_p->stat_tx_pdcp_bytes += ((struct rlc_um_tx_sdu_management *) (sdu_pP->data))->sdu_size; rlc_p->stat_tx_pdcp_bytes += ((struct rlc_um_tx_sdu_management *) (sdu_pP->data))->sdu_size;
MSC_LOG_RX_MESSAGE( MSC_LOG_RX_MESSAGE(
(ctxt_pP->enb_flag == ENB_FLAG_YES) ? MSC_RLC_ENB:MSC_RLC_UE, (ctxt_pP->enb_flag == ENB_FLAG_YES) ? MSC_RLC_ENB:MSC_RLC_UE,
(ctxt_pP->enb_flag == ENB_FLAG_YES) ? MSC_PDCP_ENB:MSC_PDCP_UE, (ctxt_pP->enb_flag == ENB_FLAG_YES) ? MSC_PDCP_ENB:MSC_PDCP_UE,
@@ -734,13 +627,11 @@ rlc_um_data_req (const protocol_ctxt_t* const ctxt_pP, void *rlc_pP, mem_block_t
PROTOCOL_RLC_UM_MSC_ARGS(ctxt_pP, rlc_p), PROTOCOL_RLC_UM_MSC_ARGS(ctxt_pP, rlc_p),
((struct rlc_um_tx_sdu_management *) (sdu_pP->data))->sdu_size); ((struct rlc_um_tx_sdu_management *) (sdu_pP->data))->sdu_size);
if (LOG_DEBUGFLAG(DEBUG_RLC) ) {
# if TRACE_RLC_UM_PDU
data_offset = sizeof (struct rlc_um_data_req_alloc); data_offset = sizeof (struct rlc_um_data_req_alloc);
data_size = ((struct rlc_um_tx_sdu_management *)(sdu_pP->data))->sdu_size; data_size = ((struct rlc_um_tx_sdu_management *)(sdu_pP->data))->sdu_size;
message_string_size += sprintf(&message_string[message_string_size], "Bearer : %u\n", rlc_p->rb_id); message_string_size += sprintf(&message_string[message_string_size], "Bearer : %u\n", rlc_p->rb_id);
message_string_size += sprintf(&message_string[message_string_size], "SDU size : %u\n", data_size); message_string_size += sprintf(&message_string[message_string_size], "SDU size : %u\n", data_size);
message_string_size += sprintf(&message_string[message_string_size], "\nPayload : \n"); message_string_size += sprintf(&message_string[message_string_size], "\nPayload : \n");
message_string_size += sprintf(&message_string[message_string_size], "------+-------------------------------------------------|\n"); message_string_size += sprintf(&message_string[message_string_size], "------+-------------------------------------------------|\n");
message_string_size += sprintf(&message_string[message_string_size], " | 0 1 2 3 4 5 6 7 8 9 a b c d e f |\n"); message_string_size += sprintf(&message_string[message_string_size], " | 0 1 2 3 4 5 6 7 8 9 a b c d e f |\n");
@@ -771,35 +662,24 @@ rlc_um_data_req (const protocol_ctxt_t* const ctxt_pP, void *rlc_pP, mem_block_t
message_string_size += sprintf(&message_string[message_string_size], " "); message_string_size += sprintf(&message_string[message_string_size], " ");
} }
message_string_size += sprintf(&message_string[message_string_size], " |\n"); LOG_UI(RLC, "%s|\n", message_string);
}
# if ENABLE_ITTI
msg_p = itti_alloc_new_message_sized (ctxt_pP->enb_flag > 0 ? TASK_RLC_ENB:TASK_RLC_UE , RLC_UM_SDU_REQ, message_string_size + sizeof (IttiMsgText));
msg_p->ittiMsg.rlc_um_sdu_req.size = message_string_size;
memcpy(&msg_p->ittiMsg.rlc_um_sdu_req.text, message_string, message_string_size);
itti_send_msg_to_task(TASK_UNKNOWN, ctxt_pP->instance, msg_p);
#else
LOG_T(RLC, "%s", message_string);
#endif
# endif
RLC_UM_MUTEX_LOCK(&rlc_p->lock_input_sdus, ctxt_pP, rlc_p); RLC_UM_MUTEX_LOCK(&rlc_p->lock_input_sdus, ctxt_pP, rlc_p);
rlc_p->buffer_occupancy += ((struct rlc_um_tx_sdu_management *) (sdu_pP->data))->sdu_size; rlc_p->buffer_occupancy += ((struct rlc_um_tx_sdu_management *) (sdu_pP->data))->sdu_size;
list_add_tail_eurecom(sdu_pP, &rlc_p->input_sdus); list_add_tail_eurecom(sdu_pP, &rlc_p->input_sdus);
RLC_UM_MUTEX_UNLOCK(&rlc_p->lock_input_sdus); RLC_UM_MUTEX_UNLOCK(&rlc_p->lock_input_sdus);
#if DEBUG_RLC_CONGESTION
#if MESSAGE_CHART_GENERATOR if (MESSAGE_CHART_GENERATOR) {
if (rlc_p->buffer_occupancy > 4096) { if (rlc_p->buffer_occupancy > 4096) {
MSC_LOG_EVENT((ctxt_pP->enb_flag == ENB_FLAG_YES) ? MSC_RLC_ENB:MSC_RLC_UE,\ MSC_LOG_EVENT((ctxt_pP->enb_flag == ENB_FLAG_YES) ? MSC_RLC_ENB:MSC_RLC_UE,\
"0 "PROTOCOL_RLC_AM_MSC_FMT" BO %u bytes",\ "0 "PROTOCOL_RLC_AM_MSC_FMT" BO %u bytes",\
PROTOCOL_RLC_AM_MSC_ARGS(ctxt_pP,rlc_pP), rlc_p->buffer_occupancy); PROTOCOL_RLC_AM_MSC_ARGS(ctxt_pP,rlc_p), rlc_p->buffer_occupancy);
} }
#else }
LOG_W(RLC, PROTOCOL_RLC_UM_CTXT_FMT" BO %d , NB SDU %d\n",
LOG_T(RLC, PROTOCOL_RLC_UM_CTXT_FMT" BO %d , NB SDU %d\n",
PROTOCOL_RLC_UM_CTXT_ARGS(ctxt_pP,rlc_p), PROTOCOL_RLC_UM_CTXT_ARGS(ctxt_pP,rlc_p),
rlc_p->buffer_occupancy, rlc_p->buffer_occupancy,
rlc_p->input_sdus.nb_elements); rlc_p->input_sdus.nb_elements);
#endif
#endif
} }
openair2/LAYER2/RLC/rlc.c
+21 -47
View File
@@ -59,9 +59,6 @@ void rlc_util_print_hex_octets(comp_name_t componentP, unsigned char* dataP, con
return; return;
} }
LOG_T(componentP, "+-----+-------------------------------------------------+\n"); LOG_T(componentP, "+-----+-------------------------------------------------+\n");
LOG_T(componentP, "| | 0 1 2 3 4 5 6 7 8 9 a b c d e f |\n"); LOG_T(componentP, "| | 0 1 2 3 4 5 6 7 8 9 a b c d e f |\n");
LOG_T(componentP, "+-----+-------------------------------------------------+\n"); LOG_T(componentP, "+-----+-------------------------------------------------+\n");
@@ -128,8 +125,7 @@ rlc_op_status_t rlc_stat_req (
unsigned int *stat_rx_control_bytes, unsigned int *stat_rx_control_bytes,
unsigned int *stat_timer_reordering_timed_out, unsigned int *stat_timer_reordering_timed_out,
unsigned int *stat_timer_poll_retransmit_timed_out, unsigned int *stat_timer_poll_retransmit_timed_out,
unsigned int* stat_timer_status_prohibit_timed_out) unsigned int *stat_timer_status_prohibit_timed_out) {
{
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
rlc_mode_t rlc_mode = RLC_MODE_NONE; rlc_mode_t rlc_mode = RLC_MODE_NONE;
rlc_union_t *rlc_union_p = NULL; rlc_union_t *rlc_union_p = NULL;
@@ -148,7 +144,9 @@ rlc_op_status_t rlc_stat_req (
if (h_rc == HASH_TABLE_OK) { if (h_rc == HASH_TABLE_OK) {
rlc_mode = rlc_union_p->mode; rlc_mode = rlc_union_p->mode;
} }
*stat_rlc_mode = rlc_mode; *stat_rlc_mode = rlc_mode;
switch (rlc_mode) { switch (rlc_mode) {
case RLC_MODE_NONE: case RLC_MODE_NONE:
*stat_tx_pdcp_sdu = 0; *stat_tx_pdcp_sdu = 0;
@@ -304,7 +302,6 @@ rlc_op_status_t rlc_stat_req (
*stat_rx_data_bytes_out_of_window = 0; *stat_rx_data_bytes_out_of_window = 0;
*stat_rx_control_pdu = 0; *stat_rx_control_pdu = 0;
*stat_rx_control_bytes = 0; *stat_rx_control_bytes = 0;
*stat_timer_poll_retransmit_timed_out = 0; *stat_timer_poll_retransmit_timed_out = 0;
*stat_timer_status_prohibit_timed_out = 0; *stat_timer_status_prohibit_timed_out = 0;
return RLC_OP_STATUS_BAD_PARAMETER; return RLC_OP_STATUS_BAD_PARAMETER;
@@ -324,15 +321,13 @@ rlc_op_status_t rlc_data_req (const protocol_ctxt_t* const ctxt_pP,
,const uint32_t *const sourceL2Id ,const uint32_t *const sourceL2Id
,const uint32_t *const destinationL2Id ,const uint32_t *const destinationL2Id
#endif #endif
) ) {
{
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
mem_block_t *new_sdu_p = NULL; mem_block_t *new_sdu_p = NULL;
rlc_mode_t rlc_mode = RLC_MODE_NONE; rlc_mode_t rlc_mode = RLC_MODE_NONE;
rlc_union_t *rlc_union_p = NULL; rlc_union_t *rlc_union_p = NULL;
hash_key_t key = HASHTABLE_NOT_A_KEY_VALUE; hash_key_t key = HASHTABLE_NOT_A_KEY_VALUE;
hashtable_rc_t h_rc; hashtable_rc_t h_rc;
#if (LTE_RRC_VERSION >= MAKE_VERSION(10, 0, 0)) #if (LTE_RRC_VERSION >= MAKE_VERSION(10, 0, 0))
rlc_mbms_id_t *mbms_id_p = NULL; rlc_mbms_id_t *mbms_id_p = NULL;
logical_chan_id_t log_ch_id = 0; logical_chan_id_t log_ch_id = 0;
@@ -351,10 +346,11 @@ rlc_op_status_t rlc_data_req (const protocol_ctxt_t* const ctxt_pP,
#else #else
AssertFatal(MBMS_flagP == 0, "MBMS_flagP %u", MBMS_flagP); AssertFatal(MBMS_flagP == 0, "MBMS_flagP %u", MBMS_flagP);
#endif #endif
#if T_TRACER #if T_TRACER
if (ctxt_pP->enb_flag) if (ctxt_pP->enb_flag)
T(T_ENB_RLC_DL, T_INT(ctxt_pP->module_id), T_INT(ctxt_pP->rnti), T_INT(rb_idP), T_INT(sdu_sizeP)); T(T_ENB_RLC_DL, T_INT(ctxt_pP->module_id), T_INT(ctxt_pP->rnti), T_INT(rb_idP), T_INT(sdu_sizeP));
#endif #endif
if (MBMS_flagP) { if (MBMS_flagP) {
@@ -386,9 +382,7 @@ rlc_op_status_t rlc_data_req (const protocol_ctxt_t* const ctxt_pP,
#if (LTE_RRC_VERSION < MAKE_VERSION(10, 0, 0)) #if (LTE_RRC_VERSION < MAKE_VERSION(10, 0, 0))
DevCheck(MBMS_flagP == 0, MBMS_flagP, 0, 0); DevCheck(MBMS_flagP == 0, MBMS_flagP, 0, 0);
#endif #endif
VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_RLC_DATA_REQ,VCD_FUNCTION_IN); VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_RLC_DATA_REQ,VCD_FUNCTION_IN);
#if (LTE_RRC_VERSION >= MAKE_VERSION(10, 0, 0)) #if (LTE_RRC_VERSION >= MAKE_VERSION(10, 0, 0))
if (MBMS_flagP == TRUE) { if (MBMS_flagP == TRUE) {
@@ -402,19 +396,19 @@ rlc_op_status_t rlc_data_req (const protocol_ctxt_t* const ctxt_pP,
key = RLC_COLL_KEY_MBMS_VALUE(ctxt_pP->module_id, ctxt_pP->rnti, ctxt_pP->enb_flag, mbms_id_p->service_id, mbms_id_p->session_id); key = RLC_COLL_KEY_MBMS_VALUE(ctxt_pP->module_id, ctxt_pP->rnti, ctxt_pP->enb_flag, mbms_id_p->service_id, mbms_id_p->session_id);
} }
if (sourceL2Id && destinationL2Id){
LOG_I (RLC, "RLC_COLL_KEY_VALUE: ctxt_pP->module_id: %d, ctxt_pP->rnti: %d, ctxt_pP->enb_flag: %d, rb_idP:%d, srb_flagP: %d \n \n", ctxt_pP->module_id, ctxt_pP->rnti, ctxt_pP->enb_flag, rb_idP, srb_flagP);
key = RLC_COLL_KEY_VALUE(ctxt_pP->module_id, ctxt_pP->rnti, ctxt_pP->enb_flag, rb_idP, srb_flagP);
if (sourceL2Id && destinationL2Id) {
LOG_D (RLC, "RLC_COLL_KEY_VALUE: ctxt_pP->module_id: %d, ctxt_pP->rnti: %d, ctxt_pP->enb_flag: %d, rb_idP:%d, srb_flagP: %d \n \n", ctxt_pP->module_id, ctxt_pP->rnti, ctxt_pP->enb_flag, rb_idP,
srb_flagP);
key = RLC_COLL_KEY_VALUE(ctxt_pP->module_id, ctxt_pP->rnti, ctxt_pP->enb_flag, rb_idP, srb_flagP);
//Thinh's line originally uncommented //Thinh's line originally uncommented
//key = RLC_COLL_KEY_SOURCE_DEST_VALUE(ctxt_pP->module_id, ctxt_pP->rnti, ctxt_pP->enb_flag, rb_idP, *sourceL2Id, *destinationL2Id, srb_flagP); //key = RLC_COLL_KEY_SOURCE_DEST_VALUE(ctxt_pP->module_id, ctxt_pP->rnti, ctxt_pP->enb_flag, rb_idP, *sourceL2Id, *destinationL2Id, srb_flagP);
//key_lcid = RLC_COLL_KEY_LCID_SOURCE_DEST_VALUE(ctxt_pP->module_id, ctxt_pP->rnti, ctxt_pP->enb_flag, chan_idP, *sourceL2Id, *destinationL2Id, srb_flagP); //key_lcid = RLC_COLL_KEY_LCID_SOURCE_DEST_VALUE(ctxt_pP->module_id, ctxt_pP->rnti, ctxt_pP->enb_flag, chan_idP, *sourceL2Id, *destinationL2Id, srb_flagP);
} else } else
#endif #endif
{ {
LOG_I (RLC, "RLC_COLL_KEY_VALUE: ctxt_pP->module_id: %d, ctxt_pP->rnti: %d, ctxt_pP->enb_flag: %d, rb_idP:%d, srb_flagP: %d \n \n", ctxt_pP->module_id, ctxt_pP->rnti, ctxt_pP->enb_flag, rb_idP, srb_flagP); LOG_D (RLC, "RLC_COLL_KEY_VALUE: ctxt_pP->module_id: %d, ctxt_pP->rnti: %d, ctxt_pP->enb_flag: %d, rb_idP:%d, srb_flagP: %d \n \n", ctxt_pP->module_id, ctxt_pP->rnti, ctxt_pP->enb_flag, rb_idP,
srb_flagP);
key = RLC_COLL_KEY_VALUE(ctxt_pP->module_id, ctxt_pP->rnti, ctxt_pP->enb_flag, rb_idP, srb_flagP); key = RLC_COLL_KEY_VALUE(ctxt_pP->module_id, ctxt_pP->rnti, ctxt_pP->enb_flag, rb_idP, srb_flagP);
} }
@@ -436,7 +430,6 @@ rlc_op_status_t rlc_data_req (const protocol_ctxt_t* const ctxt_pP,
#if defined(TRACE_RLC_PAYLOAD) #if defined(TRACE_RLC_PAYLOAD)
rlc_util_print_hex_octets(RLC, (unsigned char *)sdu_pP->data, sdu_sizeP); rlc_util_print_hex_octets(RLC, (unsigned char *)sdu_pP->data, sdu_sizeP);
#endif #endif
#ifdef DEBUG_RLC_DATA_REQ #ifdef DEBUG_RLC_DATA_REQ
LOG_D(RLC,"RLC_TYPE : %d\n", rlc_mode); LOG_D(RLC,"RLC_TYPE : %d\n", rlc_mode);
#endif #endif
@@ -460,7 +453,6 @@ rlc_op_status_t rlc_data_req (const protocol_ctxt_t* const ctxt_pP,
// PROCESS OF COMPRESSION HERE: // PROCESS OF COMPRESSION HERE:
memset (new_sdu_p->data, 0, sizeof (struct rlc_am_data_req_alloc)); memset (new_sdu_p->data, 0, sizeof (struct rlc_am_data_req_alloc));
memcpy (&new_sdu_p->data[sizeof (struct rlc_am_data_req_alloc)], &sdu_pP->data[0], sdu_sizeP); memcpy (&new_sdu_p->data[sizeof (struct rlc_am_data_req_alloc)], &sdu_pP->data[0], sdu_sizeP);
((struct rlc_am_data_req *) (new_sdu_p->data))->data_size = sdu_sizeP; ((struct rlc_am_data_req *) (new_sdu_p->data))->data_size = sdu_sizeP;
((struct rlc_am_data_req *) (new_sdu_p->data))->conf = confirmP; ((struct rlc_am_data_req *) (new_sdu_p->data))->conf = confirmP;
((struct rlc_am_data_req *) (new_sdu_p->data))->mui = muiP; ((struct rlc_am_data_req *) (new_sdu_p->data))->mui = muiP;
@@ -478,6 +470,7 @@ rlc_op_status_t rlc_data_req (const protocol_ctxt_t* const ctxt_pP,
break; break;
case RLC_MODE_UM: case RLC_MODE_UM:
/* TODO: this is a hack, needs better solution. Let's not use too /* TODO: this is a hack, needs better solution. Let's not use too
* much memory and store at maximum 5 millions bytes. * much memory and store at maximum 5 millions bytes.
*/ */
@@ -493,13 +486,10 @@ rlc_op_status_t rlc_data_req (const protocol_ctxt_t* const ctxt_pP,
// PROCESS OF COMPRESSION HERE: // PROCESS OF COMPRESSION HERE:
memset (new_sdu_p->data, 0, sizeof (struct rlc_um_data_req_alloc)); memset (new_sdu_p->data, 0, sizeof (struct rlc_um_data_req_alloc));
memcpy (&new_sdu_p->data[sizeof (struct rlc_um_data_req_alloc)], &sdu_pP->data[0], sdu_sizeP); memcpy (&new_sdu_p->data[sizeof (struct rlc_um_data_req_alloc)], &sdu_pP->data[0], sdu_sizeP);
((struct rlc_um_data_req *) (new_sdu_p->data))->data_size = sdu_sizeP; ((struct rlc_um_data_req *) (new_sdu_p->data))->data_size = sdu_sizeP;
((struct rlc_um_data_req *) (new_sdu_p->data))->data_offset = sizeof (struct rlc_um_data_req_alloc); ((struct rlc_um_data_req *) (new_sdu_p->data))->data_offset = sizeof (struct rlc_um_data_req_alloc);
free_mem_block(sdu_pP, __func__); free_mem_block(sdu_pP, __func__);
rlc_um_data_req(ctxt_pP, &rlc_union_p->rlc.um, new_sdu_p); rlc_um_data_req(ctxt_pP, &rlc_union_p->rlc.um, new_sdu_p);
//free_mem_block(new_sdu, __func__); //free_mem_block(new_sdu, __func__);
VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_RLC_DATA_REQ,VCD_FUNCTION_OUT); VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_RLC_DATA_REQ,VCD_FUNCTION_OUT);
return RLC_OP_STATUS_OK; return RLC_OP_STATUS_OK;
@@ -518,7 +508,6 @@ rlc_op_status_t rlc_data_req (const protocol_ctxt_t* const ctxt_pP,
// PROCESS OF COMPRESSION HERE: // PROCESS OF COMPRESSION HERE:
memset (new_sdu_p->data, 0, sizeof (struct rlc_tm_data_req_alloc)); memset (new_sdu_p->data, 0, sizeof (struct rlc_tm_data_req_alloc));
memcpy (&new_sdu_p->data[sizeof (struct rlc_tm_data_req_alloc)], &sdu_pP->data[0], sdu_sizeP); memcpy (&new_sdu_p->data[sizeof (struct rlc_tm_data_req_alloc)], &sdu_pP->data[0], sdu_sizeP);
((struct rlc_tm_data_req *) (new_sdu_p->data))->data_size = sdu_sizeP; ((struct rlc_tm_data_req *) (new_sdu_p->data))->data_size = sdu_sizeP;
((struct rlc_tm_data_req *) (new_sdu_p->data))->data_offset = sizeof (struct rlc_tm_data_req_alloc); ((struct rlc_tm_data_req *) (new_sdu_p->data))->data_offset = sizeof (struct rlc_tm_data_req_alloc);
free_mem_block(sdu_pP, __func__); free_mem_block(sdu_pP, __func__);
@@ -538,7 +527,6 @@ rlc_op_status_t rlc_data_req (const protocol_ctxt_t* const ctxt_pP,
free_mem_block(sdu_pP, __func__); free_mem_block(sdu_pP, __func__);
VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_RLC_DATA_REQ,VCD_FUNCTION_OUT); VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_RLC_DATA_REQ,VCD_FUNCTION_OUT);
return RLC_OP_STATUS_INTERNAL_ERROR; return RLC_OP_STATUS_INTERNAL_ERROR;
} }
#if (LTE_RRC_VERSION >= MAKE_VERSION(10, 0, 0)) #if (LTE_RRC_VERSION >= MAKE_VERSION(10, 0, 0))
@@ -557,7 +545,6 @@ rlc_op_status_t rlc_data_req (const protocol_ctxt_t* const ctxt_pP,
((struct rlc_um_data_req *) (new_sdu_p->data))->data_offset = sizeof (struct rlc_um_data_req_alloc); ((struct rlc_um_data_req *) (new_sdu_p->data))->data_offset = sizeof (struct rlc_um_data_req_alloc);
free_mem_block(sdu_pP, __func__); free_mem_block(sdu_pP, __func__);
rlc_um_data_req(ctxt_pP, &rlc_union_p->rlc.um, new_sdu_p); rlc_um_data_req(ctxt_pP, &rlc_union_p->rlc.um, new_sdu_p);
//free_mem_block(new_sdu, __func__); //free_mem_block(new_sdu, __func__);
VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_RLC_DATA_REQ,VCD_FUNCTION_OUT); VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_RLC_DATA_REQ,VCD_FUNCTION_OUT);
return RLC_OP_STATUS_OK; return RLC_OP_STATUS_OK;
@@ -578,8 +565,7 @@ rlc_op_status_t rlc_data_req (const protocol_ctxt_t* const ctxt_pP,
#else #else
} }
else /* MBMS_flag != 0 */ else { /* MBMS_flag != 0 */
{
free_mem_block(sdu_pP, __func__); free_mem_block(sdu_pP, __func__);
LOG_E(RLC, "MBMS_flag != 0 while Rel10/Rel14 is not defined...\n"); LOG_E(RLC, "MBMS_flag != 0 while Rel10/Rel14 is not defined...\n");
//handle_event(ERROR,"FILE %s FONCTION rlc_data_req() LINE %s : parameter module_id out of bounds :%d\n", __FILE__, __LINE__, module_idP); //handle_event(ERROR,"FILE %s FONCTION rlc_data_req() LINE %s : parameter module_id out of bounds :%d\n", __FILE__, __LINE__, module_idP);
@@ -597,27 +583,22 @@ void rlc_data_ind (
const MBMS_flag_t MBMS_flagP, const MBMS_flag_t MBMS_flagP,
const rb_id_t rb_idP, const rb_id_t rb_idP,
const sdu_size_t sdu_sizeP, const sdu_size_t sdu_sizeP,
mem_block_t *sdu_pP) mem_block_t *sdu_pP) {
{
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
#if defined(TRACE_RLC_PAYLOAD) #if defined(TRACE_RLC_PAYLOAD)
LOG_D(RLC, PROTOCOL_CTXT_FMT"[%s %u] Display of rlc_data_ind: size %u\n", LOG_D(RLC, PROTOCOL_CTXT_FMT"[%s %u] Display of rlc_data_ind: size %u\n",
PROTOCOL_CTXT_ARGS(ctxt_pP), PROTOCOL_CTXT_ARGS(ctxt_pP),
(srb_flagP) ? "SRB" : "DRB", (srb_flagP) ? "SRB" : "DRB",
rb_idP, rb_idP,
sdu_sizeP); sdu_sizeP);
rlc_util_print_hex_octets(RLC, (unsigned char *)sdu_pP->data, sdu_sizeP); rlc_util_print_hex_octets(RLC, (unsigned char *)sdu_pP->data, sdu_sizeP);
#endif #endif
#if T_TRACER #if T_TRACER
if (ctxt_pP->enb_flag) if (ctxt_pP->enb_flag)
T(T_ENB_RLC_UL, T_INT(ctxt_pP->module_id), T_INT(ctxt_pP->rnti), T_INT(rb_idP), T_INT(sdu_sizeP)); T(T_ENB_RLC_UL, T_INT(ctxt_pP->module_id), T_INT(ctxt_pP->rnti), T_INT(rb_idP), T_INT(sdu_sizeP));
#endif #endif
pdcp_data_ind ( pdcp_data_ind (
ctxt_pP, ctxt_pP,
srb_flagP, srb_flagP,
@@ -631,10 +612,8 @@ void rlc_data_conf (const protocol_ctxt_t* const ctxt_pP,
const srb_flag_t srb_flagP, const srb_flag_t srb_flagP,
const rb_id_t rb_idP, const rb_id_t rb_idP,
const mui_t muiP, const mui_t muiP,
const rlc_tx_status_t statusP) const rlc_tx_status_t statusP) {
{
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
if (srb_flagP) { if (srb_flagP) {
if (rlc_rrc_data_conf != NULL) { if (rlc_rrc_data_conf != NULL) {
rlc_rrc_data_conf (ctxt_pP, rb_idP , muiP, statusP); rlc_rrc_data_conf (ctxt_pP, rb_idP , muiP, statusP);
@@ -643,20 +622,17 @@ void rlc_data_conf (const protocol_ctxt_t* const ctxt_pP,
} }
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
int int
rlc_module_init (void) rlc_module_init (void) {
{
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
int k; int k;
module_id_t module_id1; module_id_t module_id1;
/* for no gcc warnings */ /* for no gcc warnings */
(void)k; (void)k;
LOG_D(RLC, "MODULE INIT\n"); LOG_D(RLC, "MODULE INIT\n");
rlc_rrc_data_ind = NULL; rlc_rrc_data_ind = NULL;
rlc_rrc_data_conf = NULL; rlc_rrc_data_conf = NULL;
rlc_coll_p = hashtable_create ((LTE_maxDRB + 2) * 16, NULL, rb_free_rlc_union); rlc_coll_p = hashtable_create ((LTE_maxDRB + 2) * 16, NULL, rb_free_rlc_union);
//AssertFatal(rlc_coll_p != NULL, "UNRECOVERABLE error, RLC hashtable_create failed"); //AssertFatal(rlc_coll_p != NULL, "UNRECOVERABLE error, RLC hashtable_create failed");
if(rlc_coll_p == NULL) { if(rlc_coll_p == NULL) {
LOG_E(RLC, "UNRECOVERABLE error, RLC hashtable_create failed\n"); LOG_E(RLC, "UNRECOVERABLE error, RLC hashtable_create failed\n");
@@ -694,7 +670,6 @@ rlc_module_init (void)
} }
pool_buffer_init(); pool_buffer_init();
return(0); return(0);
} }
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
@@ -706,8 +681,7 @@ rlc_module_cleanup (void)
} }
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
void void
rlc_layer_init (void) rlc_layer_init (void) {
{
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
} }
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
openair2/RRC/LTE/MESSAGES/asn1_msg_NB_IoT.c
+24 -308
View File
File diff suppressed because it is too large Load Diff
openair2/RRC/LTE/rrc_UE.c
+194 -717
View File
File diff suppressed because it is too large Load Diff
openair2/RRC/LTE/rrc_eNB.c
-35
View File
@@ -5499,37 +5499,6 @@ rrc_eNB_decode_ccch(
0, 0,
0); 0);
/*
#if defined(ENABLE_ITTI)
# if defined(DISABLE_ITTI_XER_PRINT)
{
MessageDef *message_p;
message_p = itti_alloc_new_message(TASK_RRC_ENB, RRC_UL_CCCH_MESSAGE);
memcpy(&message_p->ittiMsg, (void *)ul_ccch_msg, sizeof(RrcUlCcchMessage));
itti_send_msg_to_task(TASK_UNKNOWN, ctxt_pP->instance, message_p);
}
# else
{
char message_string[10000];
size_t message_string_size;
if ((message_string_size =
xer_sprint(message_string, sizeof(message_string), &asn_DEF_LTE_UL_CCCH_Message, (void *)ul_ccch_msg)) > 0) {
MessageDef *msg_p;
msg_p = itti_alloc_new_message_sized(TASK_RRC_ENB, RRC_UL_CCCH, message_string_size + sizeof(IttiMsgText));
msg_p->ittiMsg.rrc_ul_ccch.size = message_string_size;
memcpy(&msg_p->ittiMsg.rrc_ul_ccch.text, message_string, message_string_size);
itti_send_msg_to_task(TASK_UNKNOWN, ctxt_pP->instance, msg_p);
}
}
# endif
#endif
*/
for (i = 0; i < 8; i++) { for (i = 0; i < 8; i++) {
LOG_T(RRC, "%x.", ((uint8_t *) & ul_ccch_msg)[i]); LOG_T(RRC, "%x.", ((uint8_t *) & ul_ccch_msg)[i]);
} }
@@ -6017,12 +5986,8 @@ rrc_eNB_decode_dcch(
LTE_UL_DCCH_Message_t *ul_dcch_msg = NULL; //&uldcchmsg; LTE_UL_DCCH_Message_t *ul_dcch_msg = NULL; //&uldcchmsg;
int i; int i;
struct rrc_eNB_ue_context_s *ue_context_p = NULL; struct rrc_eNB_ue_context_s *ue_context_p = NULL;
#if defined(ENABLE_ITTI)
# if defined(ENABLE_USE_MME)
MessageDef *msg_delete_tunnels_p = NULL; MessageDef *msg_delete_tunnels_p = NULL;
uint8_t xid; uint8_t xid;
#endif
#endif
int dedicated_DRB=0; int dedicated_DRB=0;
T(T_ENB_RRC_UL_DCCH_DATA_IN, T_INT(ctxt_pP->module_id), T_INT(ctxt_pP->frame), T(T_ENB_RRC_UL_DCCH_DATA_IN, T_INT(ctxt_pP->module_id), T_INT(ctxt_pP->frame),
T_INT(ctxt_pP->subframe), T_INT(ctxt_pP->rnti)); T_INT(ctxt_pP->subframe), T_INT(ctxt_pP->rnti));
openair2/X2AP/x2ap_eNB.c
+17 -73
View File
@@ -67,30 +67,21 @@ void x2ap_eNB_register_eNB(x2ap_eNB_instance_t *instance_p,
static static
void x2ap_eNB_handle_sctp_data_ind(instance_t instance, sctp_data_ind_t *sctp_data_ind) { void x2ap_eNB_handle_sctp_data_ind(instance_t instance, sctp_data_ind_t *sctp_data_ind) {
int result; int result;
DevAssert(sctp_data_ind != NULL); DevAssert(sctp_data_ind != NULL);
x2ap_eNB_handle_message(instance, sctp_data_ind->assoc_id, sctp_data_ind->stream, x2ap_eNB_handle_message(instance, sctp_data_ind->assoc_id, sctp_data_ind->stream,
sctp_data_ind->buffer, sctp_data_ind->buffer_length); sctp_data_ind->buffer, sctp_data_ind->buffer_length);
result = itti_free(TASK_UNKNOWN, sctp_data_ind->buffer); result = itti_free(TASK_UNKNOWN, sctp_data_ind->buffer);
AssertFatal (result == EXIT_SUCCESS, "Failed to free memory (%d)!\n", result); AssertFatal (result == EXIT_SUCCESS, "Failed to free memory (%d)!\n", result);
} }
static static
void x2ap_eNB_handle_sctp_association_resp(instance_t instance, sctp_new_association_resp_t *sctp_new_association_resp) void x2ap_eNB_handle_sctp_association_resp(instance_t instance, sctp_new_association_resp_t *sctp_new_association_resp) {
{
x2ap_eNB_instance_t *instance_p; x2ap_eNB_instance_t *instance_p;
x2ap_eNB_data_t *x2ap_enb_data_p; x2ap_eNB_data_t *x2ap_enb_data_p;
DevAssert(sctp_new_association_resp != NULL); DevAssert(sctp_new_association_resp != NULL);
printf("x2ap_eNB_handle_sctp_association_resp at 1\n"); printf("x2ap_eNB_handle_sctp_association_resp at 1\n");
dump_trees(); dump_trees();
instance_p = x2ap_eNB_get_instance(instance); instance_p = x2ap_eNB_get_instance(instance);
DevAssert(instance_p != NULL); DevAssert(instance_p != NULL);
@@ -100,12 +91,14 @@ dump_trees();
if (sctp_new_association_resp->assoc_id != -1) { if (sctp_new_association_resp->assoc_id != -1) {
x2ap_enb_data_p = x2ap_get_eNB(instance_p, sctp_new_association_resp->assoc_id, x2ap_enb_data_p = x2ap_get_eNB(instance_p, sctp_new_association_resp->assoc_id,
sctp_new_association_resp->ulp_cnx_id); sctp_new_association_resp->ulp_cnx_id);
if (x2ap_enb_data_p != NULL) { if (x2ap_enb_data_p != NULL) {
/* some sanity check - to be refined at some point */ /* some sanity check - to be refined at some point */
if (sctp_new_association_resp->sctp_state != SCTP_STATE_ESTABLISHED) { if (sctp_new_association_resp->sctp_state != SCTP_STATE_ESTABLISHED) {
X2AP_ERROR("x2ap_enb_data_p not NULL and sctp state not SCTP_STATE_ESTABLISHED, what to do?\n"); X2AP_ERROR("x2ap_enb_data_p not NULL and sctp state not SCTP_STATE_ESTABLISHED, what to do?\n");
abort(); abort();
} }
x2ap_enb_data_p->in_streams = sctp_new_association_resp->in_streams; x2ap_enb_data_p->in_streams = sctp_new_association_resp->in_streams;
x2ap_enb_data_p->out_streams = sctp_new_association_resp->out_streams; x2ap_enb_data_p->out_streams = sctp_new_association_resp->out_streams;
return; return;
@@ -115,7 +108,6 @@ dump_trees();
x2ap_enb_data_p = x2ap_get_eNB(instance_p, -1, x2ap_enb_data_p = x2ap_get_eNB(instance_p, -1,
sctp_new_association_resp->ulp_cnx_id); sctp_new_association_resp->ulp_cnx_id);
DevAssert(x2ap_enb_data_p != NULL); DevAssert(x2ap_enb_data_p != NULL);
printf("x2ap_eNB_handle_sctp_association_resp at 2\n"); printf("x2ap_eNB_handle_sctp_association_resp at 2\n");
dump_trees(); dump_trees();
@@ -124,59 +116,50 @@ dump_trees();
sctp_new_association_resp->sctp_state, sctp_new_association_resp->sctp_state,
instance, instance,
sctp_new_association_resp->ulp_cnx_id); sctp_new_association_resp->ulp_cnx_id);
x2ap_handle_x2_setup_message(x2ap_enb_data_p, x2ap_handle_x2_setup_message(x2ap_enb_data_p,
sctp_new_association_resp->sctp_state == SCTP_STATE_SHUTDOWN); sctp_new_association_resp->sctp_state == SCTP_STATE_SHUTDOWN);
return; return;
} }
printf("x2ap_eNB_handle_sctp_association_resp at 3\n"); printf("x2ap_eNB_handle_sctp_association_resp at 3\n");
dump_trees(); dump_trees();
/* Update parameters */ /* Update parameters */
x2ap_enb_data_p->assoc_id = sctp_new_association_resp->assoc_id; x2ap_enb_data_p->assoc_id = sctp_new_association_resp->assoc_id;
x2ap_enb_data_p->in_streams = sctp_new_association_resp->in_streams; x2ap_enb_data_p->in_streams = sctp_new_association_resp->in_streams;
x2ap_enb_data_p->out_streams = sctp_new_association_resp->out_streams; x2ap_enb_data_p->out_streams = sctp_new_association_resp->out_streams;
printf("x2ap_eNB_handle_sctp_association_resp at 4\n"); printf("x2ap_eNB_handle_sctp_association_resp at 4\n");
dump_trees(); dump_trees();
/* Prepare new x2 Setup Request */ /* Prepare new x2 Setup Request */
x2ap_eNB_generate_x2_setup_request(instance_p, x2ap_enb_data_p); x2ap_eNB_generate_x2_setup_request(instance_p, x2ap_enb_data_p);
} }
static static
void x2ap_eNB_handle_sctp_association_ind(instance_t instance, sctp_new_association_ind_t *sctp_new_association_ind) void x2ap_eNB_handle_sctp_association_ind(instance_t instance, sctp_new_association_ind_t *sctp_new_association_ind) {
{
x2ap_eNB_instance_t *instance_p; x2ap_eNB_instance_t *instance_p;
x2ap_eNB_data_t *x2ap_enb_data_p; x2ap_eNB_data_t *x2ap_enb_data_p;
printf("x2ap_eNB_handle_sctp_association_ind at 1 (called for instance %d)\n", instance); printf("x2ap_eNB_handle_sctp_association_ind at 1 (called for instance %d)\n", instance);
dump_trees(); dump_trees();
DevAssert(sctp_new_association_ind != NULL); DevAssert(sctp_new_association_ind != NULL);
instance_p = x2ap_eNB_get_instance(instance); instance_p = x2ap_eNB_get_instance(instance);
DevAssert(instance_p != NULL); DevAssert(instance_p != NULL);
x2ap_enb_data_p = x2ap_get_eNB(instance_p, sctp_new_association_ind->assoc_id, -1); x2ap_enb_data_p = x2ap_get_eNB(instance_p, sctp_new_association_ind->assoc_id, -1);
if (x2ap_enb_data_p != NULL) abort(); if (x2ap_enb_data_p != NULL) abort();
// DevAssert(x2ap_enb_data_p != NULL); // DevAssert(x2ap_enb_data_p != NULL);
if (x2ap_enb_data_p == NULL) { if (x2ap_enb_data_p == NULL) {
/* Create new eNB descriptor */ /* Create new eNB descriptor */
x2ap_enb_data_p = calloc(1, sizeof(*x2ap_enb_data_p)); x2ap_enb_data_p = calloc(1, sizeof(*x2ap_enb_data_p));
DevAssert(x2ap_enb_data_p != NULL); DevAssert(x2ap_enb_data_p != NULL);
x2ap_enb_data_p->cnx_id = x2ap_eNB_fetch_add_global_cnx_id(); x2ap_enb_data_p->cnx_id = x2ap_eNB_fetch_add_global_cnx_id();
x2ap_enb_data_p->x2ap_eNB_instance = instance_p; x2ap_enb_data_p->x2ap_eNB_instance = instance_p;
/* Insert the new descriptor in list of known eNB /* Insert the new descriptor in list of known eNB
* but not yet associated. * but not yet associated.
*/ */
RB_INSERT(x2ap_enb_map, &instance_p->x2ap_enb_head, x2ap_enb_data_p); RB_INSERT(x2ap_enb_map, &instance_p->x2ap_enb_head, x2ap_enb_data_p);
x2ap_enb_data_p->state = X2AP_ENB_STATE_CONNECTED; x2ap_enb_data_p->state = X2AP_ENB_STATE_CONNECTED;
instance_p->x2_target_enb_nb++; instance_p->x2_target_enb_nb++;
if (instance_p->x2_target_enb_pending_nb > 0) { if (instance_p->x2_target_enb_pending_nb > 0) {
instance_p->x2_target_enb_pending_nb--; instance_p->x2_target_enb_pending_nb--;
} }
@@ -190,31 +173,25 @@ dump_trees();
x2ap_enb_data_p->assoc_id = sctp_new_association_ind->assoc_id; x2ap_enb_data_p->assoc_id = sctp_new_association_ind->assoc_id;
x2ap_enb_data_p->in_streams = sctp_new_association_ind->in_streams; x2ap_enb_data_p->in_streams = sctp_new_association_ind->in_streams;
x2ap_enb_data_p->out_streams = sctp_new_association_ind->out_streams; x2ap_enb_data_p->out_streams = sctp_new_association_ind->out_streams;
printf("x2ap_eNB_handle_sctp_association_ind at 3\n"); printf("x2ap_eNB_handle_sctp_association_ind at 3\n");
dump_trees(); dump_trees();
} }
int x2ap_eNB_init_sctp (x2ap_eNB_instance_t *instance_p, int x2ap_eNB_init_sctp (x2ap_eNB_instance_t *instance_p,
net_ip_address_t *local_ip_addr, net_ip_address_t *local_ip_addr,
uint32_t enb_port_for_X2C) uint32_t enb_port_for_X2C) {
{
// Create and alloc new message // Create and alloc new message
MessageDef *message; MessageDef *message;
sctp_init_t *sctp_init = NULL; sctp_init_t *sctp_init = NULL;
DevAssert(instance_p != NULL); DevAssert(instance_p != NULL);
DevAssert(local_ip_addr != NULL); DevAssert(local_ip_addr != NULL);
message = itti_alloc_new_message (TASK_X2AP, SCTP_INIT_MSG_MULTI_REQ); message = itti_alloc_new_message (TASK_X2AP, SCTP_INIT_MSG_MULTI_REQ);
sctp_init = &message->ittiMsg.sctp_init_multi; sctp_init = &message->ittiMsg.sctp_init_multi;
sctp_init->port = enb_port_for_X2C; sctp_init->port = enb_port_for_X2C;
sctp_init->ppid = X2AP_SCTP_PPID; sctp_init->ppid = X2AP_SCTP_PPID;
sctp_init->ipv4 = 1; sctp_init->ipv4 = 1;
sctp_init->ipv6 = 0; sctp_init->ipv6 = 0;
sctp_init->nb_ipv4_addr = 1; sctp_init->nb_ipv4_addr = 1;
#if 0 #if 0
memcpy(&sctp_init->ipv4_address, memcpy(&sctp_init->ipv4_address,
local_ip_addr, local_ip_addr,
@@ -227,9 +204,7 @@ int x2ap_eNB_init_sctp (x2ap_eNB_instance_t *instance_p,
*/ */
sctp_init->nb_ipv6_addr = 0; sctp_init->nb_ipv6_addr = 0;
sctp_init->ipv6_address[0] = "0:0:0:0:0:0:0:1"; sctp_init->ipv6_address[0] = "0:0:0:0:0:0:0:1";
return itti_send_msg_to_task (TASK_SCTP, instance_p->instance, message); return itti_send_msg_to_task (TASK_SCTP, instance_p->instance, message);
} }
static void x2ap_eNB_register_eNB(x2ap_eNB_instance_t *instance_p, static void x2ap_eNB_register_eNB(x2ap_eNB_instance_t *instance_p,
@@ -238,46 +213,32 @@ static void x2ap_eNB_register_eNB(x2ap_eNB_instance_t *instance_p,
uint16_t in_streams, uint16_t in_streams,
uint16_t out_streams, uint16_t out_streams,
uint32_t enb_port_for_X2C, uint32_t enb_port_for_X2C,
int multi_sd) int multi_sd) {
{
MessageDef *message = NULL; MessageDef *message = NULL;
sctp_new_association_req_multi_t *sctp_new_association_req = NULL; sctp_new_association_req_multi_t *sctp_new_association_req = NULL;
x2ap_eNB_data_t *x2ap_enb_data = NULL; x2ap_eNB_data_t *x2ap_enb_data = NULL;
DevAssert(instance_p != NULL); DevAssert(instance_p != NULL);
DevAssert(target_eNB_ip_address != NULL); DevAssert(target_eNB_ip_address != NULL);
message = itti_alloc_new_message(TASK_X2AP, SCTP_NEW_ASSOCIATION_REQ_MULTI); message = itti_alloc_new_message(TASK_X2AP, SCTP_NEW_ASSOCIATION_REQ_MULTI);
sctp_new_association_req = &message->ittiMsg.sctp_new_association_req_multi; sctp_new_association_req = &message->ittiMsg.sctp_new_association_req_multi;
sctp_new_association_req->port = enb_port_for_X2C; sctp_new_association_req->port = enb_port_for_X2C;
sctp_new_association_req->ppid = X2AP_SCTP_PPID; sctp_new_association_req->ppid = X2AP_SCTP_PPID;
sctp_new_association_req->in_streams = in_streams; sctp_new_association_req->in_streams = in_streams;
sctp_new_association_req->out_streams = out_streams; sctp_new_association_req->out_streams = out_streams;
sctp_new_association_req->multi_sd = multi_sd; sctp_new_association_req->multi_sd = multi_sd;
memcpy(&sctp_new_association_req->remote_address, memcpy(&sctp_new_association_req->remote_address,
target_eNB_ip_address, target_eNB_ip_address,
sizeof(*target_eNB_ip_address)); sizeof(*target_eNB_ip_address));
memcpy(&sctp_new_association_req->local_address, memcpy(&sctp_new_association_req->local_address,
local_ip_addr, local_ip_addr,
sizeof(*local_ip_addr)); sizeof(*local_ip_addr));
/* Create new eNB descriptor */ /* Create new eNB descriptor */
x2ap_enb_data = calloc(1, sizeof(*x2ap_enb_data)); x2ap_enb_data = calloc(1, sizeof(*x2ap_enb_data));
DevAssert(x2ap_enb_data != NULL); DevAssert(x2ap_enb_data != NULL);
x2ap_enb_data->cnx_id = x2ap_eNB_fetch_add_global_cnx_id(); x2ap_enb_data->cnx_id = x2ap_eNB_fetch_add_global_cnx_id();
sctp_new_association_req->ulp_cnx_id = x2ap_enb_data->cnx_id; sctp_new_association_req->ulp_cnx_id = x2ap_enb_data->cnx_id;
x2ap_enb_data->assoc_id = -1; x2ap_enb_data->assoc_id = -1;
x2ap_enb_data->x2ap_eNB_instance = instance_p; x2ap_enb_data->x2ap_eNB_instance = instance_p;
/* Insert the new descriptor in list of known eNB /* Insert the new descriptor in list of known eNB
* but not yet associated. * but not yet associated.
*/ */
@@ -285,18 +246,14 @@ static void x2ap_eNB_register_eNB(x2ap_eNB_instance_t *instance_p,
x2ap_enb_data->state = X2AP_ENB_STATE_WAITING; x2ap_enb_data->state = X2AP_ENB_STATE_WAITING;
instance_p->x2_target_enb_nb ++; instance_p->x2_target_enb_nb ++;
instance_p->x2_target_enb_pending_nb ++; instance_p->x2_target_enb_pending_nb ++;
itti_send_msg_to_task(TASK_SCTP, instance_p->instance, message); itti_send_msg_to_task(TASK_SCTP, instance_p->instance, message);
} }
static static
void x2ap_eNB_handle_register_eNB(instance_t instance, void x2ap_eNB_handle_register_eNB(instance_t instance,
x2ap_register_enb_req_t *x2ap_register_eNB) x2ap_register_enb_req_t *x2ap_register_eNB) {
{
x2ap_eNB_instance_t *new_instance; x2ap_eNB_instance_t *new_instance;
DevAssert(x2ap_register_eNB != NULL); DevAssert(x2ap_register_eNB != NULL);
/* Look if the provided instance already exists */ /* Look if the provided instance already exists */
new_instance = x2ap_eNB_get_instance(instance); new_instance = x2ap_eNB_get_instance(instance);
@@ -308,13 +265,10 @@ void x2ap_eNB_handle_register_eNB(instance_t instance,
DevCheck(new_instance->mcc == x2ap_register_eNB->mcc, new_instance->mcc, x2ap_register_eNB->mcc, 0); DevCheck(new_instance->mcc == x2ap_register_eNB->mcc, new_instance->mcc, x2ap_register_eNB->mcc, 0);
DevCheck(new_instance->mnc == x2ap_register_eNB->mnc, new_instance->mnc, x2ap_register_eNB->mnc, 0); DevCheck(new_instance->mnc == x2ap_register_eNB->mnc, new_instance->mnc, x2ap_register_eNB->mnc, 0);
X2AP_WARN("eNB[%d] already registered\n", instance); X2AP_WARN("eNB[%d] already registered\n", instance);
} } else {
else {
new_instance = calloc(1, sizeof(x2ap_eNB_instance_t)); new_instance = calloc(1, sizeof(x2ap_eNB_instance_t));
DevAssert(new_instance != NULL); DevAssert(new_instance != NULL);
RB_INIT(&new_instance->x2ap_enb_head); RB_INIT(&new_instance->x2ap_enb_head);
/* Copy usefull parameters */ /* Copy usefull parameters */
new_instance->instance = instance; new_instance->instance = instance;
new_instance->eNB_name = x2ap_register_eNB->eNB_name; new_instance->eNB_name = x2ap_register_eNB->eNB_name;
@@ -324,7 +278,6 @@ void x2ap_eNB_handle_register_eNB(instance_t instance,
new_instance->mcc = x2ap_register_eNB->mcc; new_instance->mcc = x2ap_register_eNB->mcc;
new_instance->mnc = x2ap_register_eNB->mnc; new_instance->mnc = x2ap_register_eNB->mnc;
new_instance->mnc_digit_length = x2ap_register_eNB->mnc_digit_length; new_instance->mnc_digit_length = x2ap_register_eNB->mnc_digit_length;
new_instance->num_cc = x2ap_register_eNB->num_cc; new_instance->num_cc = x2ap_register_eNB->num_cc;
for (int i = 0; i< x2ap_register_eNB->num_cc; i++) { for (int i = 0; i< x2ap_register_eNB->num_cc; i++) {
@@ -343,25 +296,24 @@ void x2ap_eNB_handle_register_eNB(instance_t instance,
memcpy(new_instance->target_enb_x2_ip_address, memcpy(new_instance->target_enb_x2_ip_address,
x2ap_register_eNB->target_enb_x2_ip_address, x2ap_register_eNB->target_enb_x2_ip_address,
x2ap_register_eNB->nb_x2 * sizeof(net_ip_address_t)); x2ap_register_eNB->nb_x2 * sizeof(net_ip_address_t));
new_instance->nb_x2 = x2ap_register_eNB->nb_x2; new_instance->nb_x2 = x2ap_register_eNB->nb_x2;
new_instance->enb_x2_ip_address = x2ap_register_eNB->enb_x2_ip_address; new_instance->enb_x2_ip_address = x2ap_register_eNB->enb_x2_ip_address;
new_instance->sctp_in_streams = x2ap_register_eNB->sctp_in_streams; new_instance->sctp_in_streams = x2ap_register_eNB->sctp_in_streams;
new_instance->sctp_out_streams = x2ap_register_eNB->sctp_out_streams; new_instance->sctp_out_streams = x2ap_register_eNB->sctp_out_streams;
new_instance->enb_port_for_X2C = x2ap_register_eNB->enb_port_for_X2C; new_instance->enb_port_for_X2C = x2ap_register_eNB->enb_port_for_X2C;
/* Add the new instance to the list of eNB (meaningfull in virtual mode) */ /* Add the new instance to the list of eNB (meaningfull in virtual mode) */
x2ap_eNB_insert_new_instance(new_instance); x2ap_eNB_insert_new_instance(new_instance);
X2AP_INFO("Registered new eNB[%d] and %s eNB id %u\n", X2AP_INFO("Registered new eNB[%d] and %s eNB id %u\n",
instance, instance,
x2ap_register_eNB->cell_type == CELL_MACRO_ENB ? "macro" : "home", x2ap_register_eNB->cell_type == CELL_MACRO_ENB ? "macro" : "home",
x2ap_register_eNB->eNB_id); x2ap_register_eNB->eNB_id);
/* initiate the SCTP listener */ /* initiate the SCTP listener */
if (x2ap_eNB_init_sctp(new_instance,&x2ap_register_eNB->enb_x2_ip_address,x2ap_register_eNB->enb_port_for_X2C) < 0 ) { if (x2ap_eNB_init_sctp(new_instance,&x2ap_register_eNB->enb_x2_ip_address,x2ap_register_eNB->enb_port_for_X2C) < 0 ) {
X2AP_ERROR ("Error while sending SCTP_INIT_MSG to SCTP \n"); X2AP_ERROR ("Error while sending SCTP_INIT_MSG to SCTP \n");
return; return;
} }
X2AP_INFO("eNB[%d] eNB id %u acting as a listner (server)\n", X2AP_INFO("eNB[%d] eNB id %u acting as a listner (server)\n",
instance, x2ap_register_eNB->eNB_id); instance, x2ap_register_eNB->eNB_id);
} }
@@ -370,17 +322,14 @@ void x2ap_eNB_handle_register_eNB(instance_t instance,
static static
void x2ap_eNB_handle_sctp_init_msg_multi_cnf( void x2ap_eNB_handle_sctp_init_msg_multi_cnf(
instance_t instance_id, instance_t instance_id,
sctp_init_msg_multi_cnf_t *m) sctp_init_msg_multi_cnf_t *m) {
{
x2ap_eNB_instance_t *instance; x2ap_eNB_instance_t *instance;
int index; int index;
DevAssert(m != NULL); DevAssert(m != NULL);
instance = x2ap_eNB_get_instance(instance_id); instance = x2ap_eNB_get_instance(instance_id);
DevAssert(instance != NULL); DevAssert(instance != NULL);
instance->multi_sd = m->multi_sd; instance->multi_sd = m->multi_sd;
/* Exit if CNF message reports failure. /* Exit if CNF message reports failure.
* Failure means multi_sd < 0. * Failure means multi_sd < 0.
*/ */
@@ -392,7 +341,6 @@ void x2ap_eNB_handle_sctp_init_msg_multi_cnf(
/* Trying to connect to the provided list of eNB ip address */ /* Trying to connect to the provided list of eNB ip address */
for (index = 0; index < instance->nb_x2; index++) { for (index = 0; index < instance->nb_x2; index++) {
X2AP_INFO("eNB[%d] eNB id %u acting as an initiator (client)\n", X2AP_INFO("eNB[%d] eNB id %u acting as an initiator (client)\n",
instance_id, instance->eNB_id); instance_id, instance->eNB_id);
x2ap_eNB_register_eNB(instance, x2ap_eNB_register_eNB(instance,
@@ -405,19 +353,16 @@ void x2ap_eNB_handle_sctp_init_msg_multi_cnf(
} }
} }
void *x2ap_task(void *arg) void *x2ap_task(void *arg) {
{
MessageDef *received_msg = NULL; MessageDef *received_msg = NULL;
int result; int result;
X2AP_DEBUG("Starting X2AP layer\n"); X2AP_DEBUG("Starting X2AP layer\n");
x2ap_eNB_prepare_internal_data(); x2ap_eNB_prepare_internal_data();
itti_mark_task_ready(TASK_X2AP); itti_mark_task_ready(TASK_X2AP);
while (1) { while (1) {
itti_receive_msg(TASK_X2AP, &received_msg); itti_receive_msg(TASK_X2AP, &received_msg);
switch (ITTI_MSG_ID(received_msg)) { switch (ITTI_MSG_ID(received_msg)) {
case TERMINATE_MESSAGE: case TERMINATE_MESSAGE:
X2AP_WARN(" *** Exiting X2AP thread\n"); X2AP_WARN(" *** Exiting X2AP thread\n");
@@ -457,7 +402,6 @@ void *x2ap_task(void *arg)
result = itti_free (ITTI_MSG_ORIGIN_ID(received_msg), received_msg); result = itti_free (ITTI_MSG_ORIGIN_ID(received_msg), received_msg);
AssertFatal (result == EXIT_SUCCESS, "Failed to free memory (%d)!\n", result); AssertFatal (result == EXIT_SUCCESS, "Failed to free memory (%d)!\n", result);
received_msg = NULL; received_msg = NULL;
} }
openair3/NAS/UE/nas_itti_messaging.c
+9 -113
View File
@@ -85,94 +85,13 @@ static const uint8_t esm_message_ids[] = {
ESM_STATUS, ESM_STATUS,
}; };
static int _nas_find_message_index(const uint8_t message_id, const uint8_t *message_ids, const int ids_number)
{
int i;
for(i = 0; i < ids_number; i ++) { int nas_itti_plain_msg(const char *buffer, const nas_message_t *msg, const int length, const int down_link) {
if (message_id == message_ids[i]) { return 0;
return (2 + i);
}
} }
return (1); int nas_itti_protected_msg(const char *buffer, const nas_message_t *msg, const int length, const int down_link) {
} return 0;
int nas_itti_plain_msg(const char *buffer, const nas_message_t *msg, const int length, const int down_link)
{
MessageDef *message_p;
int data_length = length < NAS_DATA_LENGHT_MAX ? length : NAS_DATA_LENGHT_MAX;
int message_type = -1;
MessagesIds messageId_raw = -1;
MessagesIds messageId_plain = -1;
/* Define message ids */
if (msg->header.protocol_discriminator == EPS_MOBILITY_MANAGEMENT_MESSAGE) {
message_type = 0;
messageId_raw = down_link ? NAS_DL_EMM_RAW_MSG : NAS_UL_EMM_RAW_MSG;
messageId_plain = down_link ? NAS_DL_EMM_PLAIN_MSG : NAS_UL_EMM_PLAIN_MSG;
} else {
if (msg->header.protocol_discriminator == EPS_SESSION_MANAGEMENT_MESSAGE) {
message_type = 1;
messageId_raw = down_link ? NAS_DL_ESM_RAW_MSG : NAS_UL_ESM_RAW_MSG;
messageId_plain = down_link ? NAS_DL_ESM_PLAIN_MSG : NAS_UL_ESM_PLAIN_MSG;
}
}
if (message_type >= 0) {
/* Create and send the RAW message */
message_p = itti_alloc_new_message(TASK_ORIGIN, messageId_raw);
NAS_DL_EMM_RAW_MSG(message_p).lenght = length;
memset ((void *) &(NAS_DL_EMM_RAW_MSG(message_p).data), 0, NAS_DATA_LENGHT_MAX);
memcpy ((void *) &(NAS_DL_EMM_RAW_MSG(message_p).data), buffer, data_length);
itti_send_msg_to_task(TASK_UNKNOWN, INSTANCE_DEFAULT, message_p);
/* Create and send the plain message */
if (message_type == 0) {
message_p = itti_alloc_new_message(TASK_ORIGIN, messageId_plain);
NAS_DL_EMM_PLAIN_MSG(message_p).present = _nas_find_message_index(msg->plain.emm.header.message_type, emm_message_ids, sizeof(emm_message_ids) / sizeof(emm_message_ids[0]));
memcpy ((void *) &(NAS_DL_EMM_PLAIN_MSG(message_p).choice), &msg->plain.emm, sizeof (EMM_msg));
} else {
message_p = itti_alloc_new_message(TASK_ORIGIN, messageId_plain);
NAS_DL_ESM_PLAIN_MSG(message_p).present = _nas_find_message_index(msg->plain.esm.header.message_type, esm_message_ids, sizeof(esm_message_ids) / sizeof(esm_message_ids[0]));
memcpy ((void *) &(NAS_DL_ESM_PLAIN_MSG(message_p).choice), &msg->plain.esm, sizeof (ESM_msg));
}
return itti_send_msg_to_task(TASK_UNKNOWN, INSTANCE_DEFAULT, message_p);
}
return EXIT_FAILURE;
}
int nas_itti_protected_msg(const char *buffer, const nas_message_t *msg, const int length, const int down_link)
{
MessageDef *message_p = NULL;
if (msg->header.protocol_discriminator == EPS_MOBILITY_MANAGEMENT_MESSAGE) {
message_p = itti_alloc_new_message(TASK_ORIGIN, down_link ? NAS_DL_EMM_PROTECTED_MSG : NAS_UL_EMM_PROTECTED_MSG);
memcpy ((void *) &(NAS_DL_EMM_PROTECTED_MSG(message_p).header), &msg->header, sizeof (nas_message_security_header_t));
NAS_DL_EMM_PROTECTED_MSG(message_p).present = _nas_find_message_index(msg->security_protected.plain.emm.header.message_type, emm_message_ids, sizeof(emm_message_ids) / sizeof(emm_message_ids[0]));
memcpy ((void *) &(NAS_DL_EMM_PROTECTED_MSG(message_p).choice), &msg->security_protected.plain.emm, sizeof (EMM_msg));
} else {
if (msg->header.protocol_discriminator == EPS_SESSION_MANAGEMENT_MESSAGE) {
message_p = itti_alloc_new_message(TASK_ORIGIN, down_link ? NAS_DL_ESM_PROTECTED_MSG : NAS_UL_ESM_PROTECTED_MSG);
memcpy ((void *) &(NAS_DL_ESM_PROTECTED_MSG(message_p).header), &msg->header, sizeof (nas_message_security_header_t));
NAS_DL_ESM_PROTECTED_MSG(message_p).present = _nas_find_message_index(msg->security_protected.plain.esm.header.message_type, esm_message_ids, sizeof(esm_message_ids) / sizeof(esm_message_ids[0]));
memcpy ((void *) &(NAS_DL_ESM_PROTECTED_MSG(message_p).choice), &msg->security_protected.plain.esm, sizeof (ESM_msg));
}
}
if (message_p != NULL) {
return itti_send_msg_to_task(TASK_UNKNOWN, INSTANCE_DEFAULT, message_p);
}
return EXIT_FAILURE;
} }
#endif #endif
@@ -180,14 +99,10 @@ int nas_itti_protected_msg(const char *buffer, const nas_message_t *msg, const i
extern unsigned char NB_eNB_INST; extern unsigned char NB_eNB_INST;
int nas_itti_kenb_refresh_req(const Byte_t kenb[32]) int nas_itti_kenb_refresh_req(const Byte_t kenb[32]) {
{
MessageDef *message_p; MessageDef *message_p;
message_p = itti_alloc_new_message(TASK_NAS_UE, NAS_KENB_REFRESH_REQ); message_p = itti_alloc_new_message(TASK_NAS_UE, NAS_KENB_REFRESH_REQ);
memcpy(NAS_KENB_REFRESH_REQ(message_p).kenb, kenb, sizeof(NAS_KENB_REFRESH_REQ(message_p).kenb)); memcpy(NAS_KENB_REFRESH_REQ(message_p).kenb, kenb, sizeof(NAS_KENB_REFRESH_REQ(message_p).kenb));
MSC_LOG_TX_MESSAGE( MSC_LOG_TX_MESSAGE(
MSC_NAS_UE, MSC_NAS_UE,
MSC_RRC_UE, MSC_RRC_UE,
@@ -209,19 +124,14 @@ int nas_itti_kenb_refresh_req(const Byte_t kenb[32])
kenb[20], kenb[21], kenb[22], kenb[23], kenb[20], kenb[21], kenb[22], kenb[23],
kenb[24], kenb[25], kenb[26], kenb[27], kenb[24], kenb[25], kenb[26], kenb[27],
kenb[28], kenb[29], kenb[30], kenb[31]); kenb[28], kenb[29], kenb[30], kenb[31]);
return itti_send_msg_to_task(TASK_RRC_UE, NB_eNB_INST + 0 /* TODO to be virtualized */, message_p); return itti_send_msg_to_task(TASK_RRC_UE, NB_eNB_INST + 0 /* TODO to be virtualized */, message_p);
} }
int nas_itti_cell_info_req(const plmn_t plmnID, const Byte_t rat, int user_id) int nas_itti_cell_info_req(const plmn_t plmnID, const Byte_t rat, int user_id) {
{
MessageDef *message_p; MessageDef *message_p;
message_p = itti_alloc_new_message(TASK_NAS_UE, NAS_CELL_SELECTION_REQ); message_p = itti_alloc_new_message(TASK_NAS_UE, NAS_CELL_SELECTION_REQ);
NAS_CELL_SELECTION_REQ(message_p).plmnID = plmnID; NAS_CELL_SELECTION_REQ(message_p).plmnID = plmnID;
NAS_CELL_SELECTION_REQ(message_p).rat = rat; NAS_CELL_SELECTION_REQ(message_p).rat = rat;
MSC_LOG_TX_MESSAGE( MSC_LOG_TX_MESSAGE(
MSC_NAS_UE, MSC_NAS_UE,
MSC_RRC_UE, MSC_RRC_UE,
@@ -229,23 +139,18 @@ int nas_itti_cell_info_req(const plmn_t plmnID, const Byte_t rat, int user_id)
"0 NAS_CELL_SELECTION_REQ PLMN %X%X%X.%X%X%X", "0 NAS_CELL_SELECTION_REQ PLMN %X%X%X.%X%X%X",
plmnID.MCCdigit1, plmnID.MCCdigit2, plmnID.MCCdigit3, plmnID.MCCdigit1, plmnID.MCCdigit2, plmnID.MCCdigit3,
plmnID.MNCdigit1, plmnID.MNCdigit2, plmnID.MNCdigit3); plmnID.MNCdigit1, plmnID.MNCdigit2, plmnID.MNCdigit3);
return itti_send_msg_to_task(TASK_RRC_UE, NB_eNB_INST + user_id, message_p); return itti_send_msg_to_task(TASK_RRC_UE, NB_eNB_INST + user_id, message_p);
} }
int nas_itti_nas_establish_req(as_cause_t cause, as_call_type_t type, as_stmsi_t s_tmsi, plmn_t plmnID, Byte_t *data, uint32_t length, int user_id) int nas_itti_nas_establish_req(as_cause_t cause, as_call_type_t type, as_stmsi_t s_tmsi, plmn_t plmnID, Byte_t *data, uint32_t length, int user_id) {
{
MessageDef *message_p; MessageDef *message_p;
message_p = itti_alloc_new_message(TASK_NAS_UE, NAS_CONN_ESTABLI_REQ); message_p = itti_alloc_new_message(TASK_NAS_UE, NAS_CONN_ESTABLI_REQ);
NAS_CONN_ESTABLI_REQ(message_p).cause = cause; NAS_CONN_ESTABLI_REQ(message_p).cause = cause;
NAS_CONN_ESTABLI_REQ(message_p).type = type; NAS_CONN_ESTABLI_REQ(message_p).type = type;
NAS_CONN_ESTABLI_REQ(message_p).s_tmsi = s_tmsi; NAS_CONN_ESTABLI_REQ(message_p).s_tmsi = s_tmsi;
NAS_CONN_ESTABLI_REQ(message_p).plmnID = plmnID; NAS_CONN_ESTABLI_REQ(message_p).plmnID = plmnID;
NAS_CONN_ESTABLI_REQ(message_p).initialNasMsg.data = data; NAS_CONN_ESTABLI_REQ(message_p).initialNasMsg.data = data;
NAS_CONN_ESTABLI_REQ(message_p).initialNasMsg.length = length; NAS_CONN_ESTABLI_REQ(message_p).initialNasMsg.length = length;
MSC_LOG_TX_MESSAGE( MSC_LOG_TX_MESSAGE(
MSC_NAS_UE, MSC_NAS_UE,
MSC_RRC_UE, MSC_RRC_UE,
@@ -254,33 +159,24 @@ int nas_itti_nas_establish_req(as_cause_t cause, as_call_type_t type, as_stmsi_t
s_tmsi.MMEcode, s_tmsi.m_tmsi, s_tmsi.MMEcode, s_tmsi.m_tmsi,
plmnID.MCCdigit1, plmnID.MCCdigit2, plmnID.MCCdigit3, plmnID.MCCdigit1, plmnID.MCCdigit2, plmnID.MCCdigit3,
plmnID.MNCdigit1, plmnID.MNCdigit2, plmnID.MNCdigit3); plmnID.MNCdigit1, plmnID.MNCdigit2, plmnID.MNCdigit3);
return itti_send_msg_to_task(TASK_RRC_UE, NB_eNB_INST + user_id, message_p); return itti_send_msg_to_task(TASK_RRC_UE, NB_eNB_INST + user_id, message_p);
} }
int nas_itti_ul_data_req(const uint32_t ue_id, void *const data, const uint32_t length, int user_id) int nas_itti_ul_data_req(const uint32_t ue_id, void *const data, const uint32_t length, int user_id) {
{
MessageDef *message_p; MessageDef *message_p;
message_p = itti_alloc_new_message(TASK_NAS_UE, NAS_UPLINK_DATA_REQ); message_p = itti_alloc_new_message(TASK_NAS_UE, NAS_UPLINK_DATA_REQ);
NAS_UPLINK_DATA_REQ(message_p).UEid = ue_id; NAS_UPLINK_DATA_REQ(message_p).UEid = ue_id;
NAS_UPLINK_DATA_REQ(message_p).nasMsg.data = data; NAS_UPLINK_DATA_REQ(message_p).nasMsg.data = data;
NAS_UPLINK_DATA_REQ(message_p).nasMsg.length = length; NAS_UPLINK_DATA_REQ(message_p).nasMsg.length = length;
return itti_send_msg_to_task(TASK_RRC_UE, NB_eNB_INST + user_id, message_p); return itti_send_msg_to_task(TASK_RRC_UE, NB_eNB_INST + user_id, message_p);
} }
int nas_itti_rab_establish_rsp(const as_stmsi_t s_tmsi, const as_rab_id_t rabID, const nas_error_code_t errCode, int user_id) int nas_itti_rab_establish_rsp(const as_stmsi_t s_tmsi, const as_rab_id_t rabID, const nas_error_code_t errCode, int user_id) {
{
MessageDef *message_p; MessageDef *message_p;
message_p = itti_alloc_new_message(TASK_NAS_UE, NAS_RAB_ESTABLI_RSP); message_p = itti_alloc_new_message(TASK_NAS_UE, NAS_RAB_ESTABLI_RSP);
NAS_RAB_ESTABLI_RSP(message_p).s_tmsi = s_tmsi; NAS_RAB_ESTABLI_RSP(message_p).s_tmsi = s_tmsi;
NAS_RAB_ESTABLI_RSP(message_p).rabID = rabID; NAS_RAB_ESTABLI_RSP(message_p).rabID = rabID;
NAS_RAB_ESTABLI_RSP(message_p).errCode = errCode; NAS_RAB_ESTABLI_RSP(message_p).errCode = errCode;
MSC_LOG_TX_MESSAGE( MSC_LOG_TX_MESSAGE(
MSC_NAS_UE, MSC_NAS_UE,
MSC_RRC_UE, MSC_RRC_UE,
openair3/S1AP/s1ap_eNB_decoder.c
+4 -74
View File
@@ -36,103 +36,52 @@
#include "s1ap_common.h" #include "s1ap_common.h"
#include "s1ap_eNB_decoder.h" #include "s1ap_eNB_decoder.h"
static int s1ap_eNB_decode_initiating_message(S1AP_S1AP_PDU_t *pdu) static int s1ap_eNB_decode_initiating_message(S1AP_S1AP_PDU_t *pdu) {
{
MessageDef *message_p;
MessagesIds message_id;
asn_encode_to_new_buffer_result_t res = { NULL, {0, NULL, NULL} }; asn_encode_to_new_buffer_result_t res = { NULL, {0, NULL, NULL} };
DevAssert(pdu != NULL); DevAssert(pdu != NULL);
switch(pdu->choice.initiatingMessage.procedureCode) { switch(pdu->choice.initiatingMessage.procedureCode) {
case S1AP_ProcedureCode_id_downlinkNASTransport: case S1AP_ProcedureCode_id_downlinkNASTransport:
res = asn_encode_to_new_buffer(NULL, ATS_CANONICAL_XER, &asn_DEF_S1AP_S1AP_PDU, pdu); res = asn_encode_to_new_buffer(NULL, ATS_CANONICAL_XER, &asn_DEF_S1AP_S1AP_PDU, pdu);
message_id = S1AP_DOWNLINK_NAS_LOG;
message_p = itti_alloc_new_message_sized(TASK_S1AP, message_id,
res.result.encoded + sizeof (IttiMsgText));
message_p->ittiMsg.s1ap_downlink_nas_log.size = res.result.encoded;
memcpy(&message_p->ittiMsg.s1ap_downlink_nas_log.text, res.buffer, res.result.encoded);
itti_send_msg_to_task(TASK_UNKNOWN, INSTANCE_DEFAULT, message_p);
free(res.buffer); free(res.buffer);
break; break;
case S1AP_ProcedureCode_id_InitialContextSetup: case S1AP_ProcedureCode_id_InitialContextSetup:
res = asn_encode_to_new_buffer(NULL, ATS_CANONICAL_XER, &asn_DEF_S1AP_S1AP_PDU, pdu); res = asn_encode_to_new_buffer(NULL, ATS_CANONICAL_XER, &asn_DEF_S1AP_S1AP_PDU, pdu);
message_id = S1AP_INITIAL_CONTEXT_SETUP_LOG;
message_p = itti_alloc_new_message_sized(TASK_S1AP, message_id,
res.result.encoded + sizeof (IttiMsgText));
message_p->ittiMsg.s1ap_initial_context_setup_log.size = res.result.encoded;
memcpy(&message_p->ittiMsg.s1ap_initial_context_setup_log.text, res.buffer, res.result.encoded);
itti_send_msg_to_task(TASK_UNKNOWN, INSTANCE_DEFAULT, message_p);
free(res.buffer); free(res.buffer);
break; break;
case S1AP_ProcedureCode_id_UEContextRelease: case S1AP_ProcedureCode_id_UEContextRelease:
res = asn_encode_to_new_buffer(NULL, ATS_CANONICAL_XER, &asn_DEF_S1AP_S1AP_PDU, pdu); res = asn_encode_to_new_buffer(NULL, ATS_CANONICAL_XER, &asn_DEF_S1AP_S1AP_PDU, pdu);
message_id = S1AP_UE_CONTEXT_RELEASE_COMMAND_LOG;
message_p = itti_alloc_new_message_sized(TASK_S1AP, message_id,
res.result.encoded + sizeof (IttiMsgText));
message_p->ittiMsg.s1ap_ue_context_release_command_log.size = res.result.encoded;
memcpy(&message_p->ittiMsg.s1ap_ue_context_release_command_log.text, res.buffer, res.result.encoded);
itti_send_msg_to_task(TASK_UNKNOWN, INSTANCE_DEFAULT, message_p);
free(res.buffer); free(res.buffer);
break; break;
case S1AP_ProcedureCode_id_Paging: case S1AP_ProcedureCode_id_Paging:
res = asn_encode_to_new_buffer(NULL, ATS_CANONICAL_XER, &asn_DEF_S1AP_S1AP_PDU, pdu); res = asn_encode_to_new_buffer(NULL, ATS_CANONICAL_XER, &asn_DEF_S1AP_S1AP_PDU, pdu);
message_id = S1AP_PAGING_LOG;
message_p = itti_alloc_new_message_sized(TASK_S1AP, message_id,
res.result.encoded + sizeof (IttiMsgText));
message_p->ittiMsg.s1ap_paging_log.size = res.result.encoded;
memcpy(&message_p->ittiMsg.s1ap_paging_log.text, res.buffer, res.result.encoded);
itti_send_msg_to_task(TASK_UNKNOWN, INSTANCE_DEFAULT, message_p);
S1AP_INFO("Paging initiating message\n"); S1AP_INFO("Paging initiating message\n");
free(res.buffer); free(res.buffer);
break; break;
case S1AP_ProcedureCode_id_E_RABSetup: case S1AP_ProcedureCode_id_E_RABSetup:
res = asn_encode_to_new_buffer(NULL, ATS_CANONICAL_XER, &asn_DEF_S1AP_S1AP_PDU, pdu); res = asn_encode_to_new_buffer(NULL, ATS_CANONICAL_XER, &asn_DEF_S1AP_S1AP_PDU, pdu);
message_id = S1AP_E_RAB_SETUP_REQUEST_LOG;
message_p = itti_alloc_new_message_sized(TASK_S1AP, message_id,
res.result.encoded + sizeof (IttiMsgText));
message_p->ittiMsg.s1ap_e_rab_setup_request_log.size = res.result.encoded;
memcpy(&message_p->ittiMsg.s1ap_e_rab_setup_request_log.text, res.buffer, res.result.encoded);
itti_send_msg_to_task(TASK_UNKNOWN, INSTANCE_DEFAULT, message_p);
free(res.buffer); free(res.buffer);
S1AP_INFO("E_RABSetup initiating message\n"); S1AP_INFO("E_RABSetup initiating message\n");
break; break;
case S1AP_ProcedureCode_id_E_RABModify: case S1AP_ProcedureCode_id_E_RABModify:
res = asn_encode_to_new_buffer(NULL, ATS_CANONICAL_XER, &asn_DEF_S1AP_S1AP_PDU, pdu); res = asn_encode_to_new_buffer(NULL, ATS_CANONICAL_XER, &asn_DEF_S1AP_S1AP_PDU, pdu);
message_id = S1AP_E_RAB_MODIFY_REQUEST_LOG;
message_p = itti_alloc_new_message_sized(TASK_S1AP, message_id,
res.result.encoded + sizeof (IttiMsgText));
message_p->ittiMsg.s1ap_e_rab_modify_request_log.size = res.result.encoded;
memcpy(&message_p->ittiMsg.s1ap_e_rab_modify_request_log.text, res.buffer, res.result.encoded);
itti_send_msg_to_task(TASK_UNKNOWN, INSTANCE_DEFAULT, message_p);
free(res.buffer); free(res.buffer);
S1AP_INFO("E_RABModify initiating message\n"); S1AP_INFO("E_RABModify initiating message\n");
break; break;
case S1AP_ProcedureCode_id_E_RABRelease: case S1AP_ProcedureCode_id_E_RABRelease:
res = asn_encode_to_new_buffer(NULL, ATS_CANONICAL_XER, &asn_DEF_S1AP_S1AP_PDU, pdu); res = asn_encode_to_new_buffer(NULL, ATS_CANONICAL_XER, &asn_DEF_S1AP_S1AP_PDU, pdu);
message_id = S1AP_E_RAB_RELEASE_REQUEST_LOG;
message_p = itti_alloc_new_message_sized(TASK_S1AP, message_id,
res.result.encoded + sizeof (IttiMsgText));
message_p->ittiMsg.s1ap_e_rab_release_request_log.size = res.result.encoded;
memcpy(&message_p->ittiMsg.s1ap_e_rab_release_request_log.text, res.buffer, res.result.encoded);
itti_send_msg_to_task(TASK_UNKNOWN, INSTANCE_DEFAULT, message_p);
free(res.buffer); free(res.buffer);
S1AP_INFO("TODO E_RABRelease initiating message\n"); S1AP_INFO("TODO E_RABRelease initiating message\n");
break; break;
case S1AP_ProcedureCode_id_ErrorIndication: case S1AP_ProcedureCode_id_ErrorIndication:
res = asn_encode_to_new_buffer(NULL, ATS_CANONICAL_XER, &asn_DEF_S1AP_S1AP_PDU, pdu); res = asn_encode_to_new_buffer(NULL, ATS_CANONICAL_XER, &asn_DEF_S1AP_S1AP_PDU, pdu);
message_id = S1AP_ERROR_INDICATION_LOG;
message_p = itti_alloc_new_message_sized(TASK_S1AP, message_id,
res.result.encoded + sizeof (IttiMsgText));
message_p->ittiMsg.s1ap_error_indication_log.size = res.result.encoded;
memcpy(&message_p->ittiMsg.s1ap_error_indication_log.text, res.buffer, res.result.encoded);
itti_send_msg_to_task(TASK_UNKNOWN, INSTANCE_DEFAULT, message_p);
free(res.buffer); free(res.buffer);
S1AP_INFO("TODO ErrorIndication initiating message\n"); S1AP_INFO("TODO ErrorIndication initiating message\n");
break; break;
@@ -148,21 +97,13 @@ static int s1ap_eNB_decode_initiating_message(S1AP_S1AP_PDU_t *pdu)
return 0; return 0;
} }
static int s1ap_eNB_decode_successful_outcome(S1AP_S1AP_PDU_t *pdu) static int s1ap_eNB_decode_successful_outcome(S1AP_S1AP_PDU_t *pdu) {
{
MessageDef *message_p;
MessagesIds message_id;
asn_encode_to_new_buffer_result_t res = { NULL, {0, NULL, NULL} }; asn_encode_to_new_buffer_result_t res = { NULL, {0, NULL, NULL} };
DevAssert(pdu != NULL); DevAssert(pdu != NULL);
switch(pdu->choice.successfulOutcome.procedureCode) { switch(pdu->choice.successfulOutcome.procedureCode) {
case S1AP_ProcedureCode_id_S1Setup: case S1AP_ProcedureCode_id_S1Setup:
res = asn_encode_to_new_buffer(NULL, ATS_CANONICAL_XER, &asn_DEF_S1AP_S1AP_PDU, pdu); res = asn_encode_to_new_buffer(NULL, ATS_CANONICAL_XER, &asn_DEF_S1AP_S1AP_PDU, pdu);
message_id = S1AP_S1_SETUP_LOG;
message_p = itti_alloc_new_message_sized(TASK_S1AP, message_id, res.result.encoded + sizeof (IttiMsgText));
message_p->ittiMsg.s1ap_s1_setup_log.size = res.result.encoded;
memcpy(&message_p->ittiMsg.s1ap_s1_setup_log.text, res.buffer, res.result.encoded);
itti_send_msg_to_task(TASK_UNKNOWN, INSTANCE_DEFAULT, message_p);
free(res.buffer); free(res.buffer);
break; break;
@@ -175,21 +116,13 @@ static int s1ap_eNB_decode_successful_outcome(S1AP_S1AP_PDU_t *pdu)
return 0; return 0;
} }
static int s1ap_eNB_decode_unsuccessful_outcome(S1AP_S1AP_PDU_t *pdu) static int s1ap_eNB_decode_unsuccessful_outcome(S1AP_S1AP_PDU_t *pdu) {
{
MessageDef *message_p;
MessagesIds message_id;
asn_encode_to_new_buffer_result_t res = { NULL, {0, NULL, NULL} }; asn_encode_to_new_buffer_result_t res = { NULL, {0, NULL, NULL} };
DevAssert(pdu != NULL); DevAssert(pdu != NULL);
switch(pdu->choice.unsuccessfulOutcome.procedureCode) { switch(pdu->choice.unsuccessfulOutcome.procedureCode) {
case S1AP_ProcedureCode_id_S1Setup: case S1AP_ProcedureCode_id_S1Setup:
res = asn_encode_to_new_buffer(NULL, ATS_CANONICAL_XER, &asn_DEF_S1AP_S1AP_PDU, pdu); res = asn_encode_to_new_buffer(NULL, ATS_CANONICAL_XER, &asn_DEF_S1AP_S1AP_PDU, pdu);
message_id = S1AP_S1_SETUP_LOG;
message_p = itti_alloc_new_message_sized(TASK_S1AP, message_id, res.result.encoded + sizeof (IttiMsgText));
message_p->ittiMsg.s1ap_s1_setup_log.size = res.result.encoded;
memcpy(&message_p->ittiMsg.s1ap_s1_setup_log.text, res.buffer, res.result.encoded);
itti_send_msg_to_task(TASK_UNKNOWN, INSTANCE_DEFAULT, message_p);
free(res.buffer); free(res.buffer);
break; break;
@@ -203,13 +136,10 @@ static int s1ap_eNB_decode_unsuccessful_outcome(S1AP_S1AP_PDU_t *pdu)
} }
int s1ap_eNB_decode_pdu(S1AP_S1AP_PDU_t *pdu, const uint8_t *const buffer, int s1ap_eNB_decode_pdu(S1AP_S1AP_PDU_t *pdu, const uint8_t *const buffer,
const uint32_t length) const uint32_t length) {
{
asn_dec_rval_t dec_ret; asn_dec_rval_t dec_ret;
DevAssert(pdu != NULL); DevAssert(pdu != NULL);
DevAssert(buffer != NULL); DevAssert(buffer != NULL);
dec_ret = aper_decode(NULL, dec_ret = aper_decode(NULL,
&asn_DEF_S1AP_S1AP_PDU, &asn_DEF_S1AP_S1AP_PDU,
(void **)&pdu, (void **)&pdu,
openair3/S1AP/s1ap_eNB_encoder.c
+4 -74
View File
@@ -47,8 +47,7 @@ static inline int s1ap_eNB_encode_successfull_outcome(S1AP_S1AP_PDU_t *pdu,
static inline int s1ap_eNB_encode_unsuccessfull_outcome(S1AP_S1AP_PDU_t *pdu, static inline int s1ap_eNB_encode_unsuccessfull_outcome(S1AP_S1AP_PDU_t *pdu,
uint8_t **buffer, uint32_t *len); uint8_t **buffer, uint32_t *len);
int s1ap_eNB_encode_pdu(S1AP_S1AP_PDU_t *pdu, uint8_t **buffer, uint32_t *len) int s1ap_eNB_encode_pdu(S1AP_S1AP_PDU_t *pdu, uint8_t **buffer, uint32_t *len) {
{
int ret = -1; int ret = -1;
DevAssert(pdu != NULL); DevAssert(pdu != NULL);
DevAssert(buffer != NULL); DevAssert(buffer != NULL);
@@ -79,71 +78,38 @@ int s1ap_eNB_encode_pdu(S1AP_S1AP_PDU_t *pdu, uint8_t **buffer, uint32_t *len)
static inline static inline
int s1ap_eNB_encode_initiating(S1AP_S1AP_PDU_t *pdu, int s1ap_eNB_encode_initiating(S1AP_S1AP_PDU_t *pdu,
uint8_t **buffer, uint32_t *len) uint8_t **buffer, uint32_t *len) {
{
MessageDef *message_p;
MessagesIds message_id;
asn_encode_to_new_buffer_result_t res = { NULL, {0, NULL, NULL} }; asn_encode_to_new_buffer_result_t res = { NULL, {0, NULL, NULL} };
DevAssert(pdu != NULL); DevAssert(pdu != NULL);
switch(pdu->choice.initiatingMessage.procedureCode) { switch(pdu->choice.initiatingMessage.procedureCode) {
case S1AP_ProcedureCode_id_S1Setup: case S1AP_ProcedureCode_id_S1Setup:
res = asn_encode_to_new_buffer(NULL, ATS_CANONICAL_XER, &asn_DEF_S1AP_S1AP_PDU, pdu); res = asn_encode_to_new_buffer(NULL, ATS_CANONICAL_XER, &asn_DEF_S1AP_S1AP_PDU, pdu);
message_id = S1AP_S1_SETUP_LOG;
message_p = itti_alloc_new_message_sized(TASK_S1AP, message_id, res.result.encoded + sizeof (IttiMsgText));
message_p->ittiMsg.s1ap_s1_setup_log.size = res.result.encoded;
memcpy(&message_p->ittiMsg.s1ap_s1_setup_log.text, res.buffer, res.result.encoded);
itti_send_msg_to_task(TASK_UNKNOWN, INSTANCE_DEFAULT, message_p);
free(res.buffer); free(res.buffer);
break; break;
case S1AP_ProcedureCode_id_uplinkNASTransport: case S1AP_ProcedureCode_id_uplinkNASTransport:
res = asn_encode_to_new_buffer(NULL, ATS_CANONICAL_XER, &asn_DEF_S1AP_S1AP_PDU, pdu); res = asn_encode_to_new_buffer(NULL, ATS_CANONICAL_XER, &asn_DEF_S1AP_S1AP_PDU, pdu);
message_id = S1AP_UPLINK_NAS_LOG;
message_p = itti_alloc_new_message_sized(TASK_S1AP, message_id, res.result.encoded + sizeof (IttiMsgText));
message_p->ittiMsg.s1ap_uplink_nas_log.size = res.result.encoded;
memcpy(&message_p->ittiMsg.s1ap_uplink_nas_log.text, res.buffer, res.result.encoded);
itti_send_msg_to_task(TASK_UNKNOWN, INSTANCE_DEFAULT, message_p);
free(res.buffer); free(res.buffer);
break; break;
case S1AP_ProcedureCode_id_UECapabilityInfoIndication: case S1AP_ProcedureCode_id_UECapabilityInfoIndication:
res = asn_encode_to_new_buffer(NULL, ATS_CANONICAL_XER, &asn_DEF_S1AP_S1AP_PDU, pdu); res = asn_encode_to_new_buffer(NULL, ATS_CANONICAL_XER, &asn_DEF_S1AP_S1AP_PDU, pdu);
message_id = S1AP_UE_CAPABILITY_IND_LOG;
message_p = itti_alloc_new_message_sized(TASK_S1AP, message_id, res.result.encoded + sizeof (IttiMsgText));
message_p->ittiMsg.s1ap_ue_capability_ind_log.size = res.result.encoded;
memcpy(&message_p->ittiMsg.s1ap_ue_capability_ind_log.text, res.buffer, res.result.encoded);
itti_send_msg_to_task(TASK_UNKNOWN, INSTANCE_DEFAULT, message_p);
free(res.buffer); free(res.buffer);
break; break;
case S1AP_ProcedureCode_id_initialUEMessage: case S1AP_ProcedureCode_id_initialUEMessage:
res = asn_encode_to_new_buffer(NULL, ATS_CANONICAL_XER, &asn_DEF_S1AP_S1AP_PDU, pdu); res = asn_encode_to_new_buffer(NULL, ATS_CANONICAL_XER, &asn_DEF_S1AP_S1AP_PDU, pdu);
message_id = S1AP_INITIAL_UE_MESSAGE_LOG;
message_p = itti_alloc_new_message_sized(TASK_S1AP, message_id, res.result.encoded + sizeof (IttiMsgText));
message_p->ittiMsg.s1ap_initial_ue_message_log.size = res.result.encoded;
memcpy(&message_p->ittiMsg.s1ap_initial_ue_message_log.text, res.buffer, res.result.encoded);
itti_send_msg_to_task(TASK_UNKNOWN, INSTANCE_DEFAULT, message_p);
free(res.buffer); free(res.buffer);
break; break;
case S1AP_ProcedureCode_id_NASNonDeliveryIndication: case S1AP_ProcedureCode_id_NASNonDeliveryIndication:
res = asn_encode_to_new_buffer(NULL, ATS_CANONICAL_XER, &asn_DEF_S1AP_S1AP_PDU, pdu); res = asn_encode_to_new_buffer(NULL, ATS_CANONICAL_XER, &asn_DEF_S1AP_S1AP_PDU, pdu);
message_id = S1AP_NAS_NON_DELIVERY_IND_LOG;
message_p = itti_alloc_new_message_sized(TASK_S1AP, message_id, res.result.encoded + sizeof (IttiMsgText));
message_p->ittiMsg.s1ap_nas_non_delivery_ind_log.size = res.result.encoded;
memcpy(&message_p->ittiMsg.s1ap_nas_non_delivery_ind_log.text, res.buffer, res.result.encoded);
itti_send_msg_to_task(TASK_UNKNOWN, INSTANCE_DEFAULT, message_p);
free(res.buffer); free(res.buffer);
break; break;
case S1AP_ProcedureCode_id_UEContextReleaseRequest: case S1AP_ProcedureCode_id_UEContextReleaseRequest:
res = asn_encode_to_new_buffer(NULL, ATS_CANONICAL_XER, &asn_DEF_S1AP_S1AP_PDU, pdu); res = asn_encode_to_new_buffer(NULL, ATS_CANONICAL_XER, &asn_DEF_S1AP_S1AP_PDU, pdu);
message_id = S1AP_UE_CONTEXT_RELEASE_REQ_LOG;
message_p = itti_alloc_new_message_sized(TASK_S1AP, message_id, res.result.encoded + sizeof (IttiMsgText));
message_p->ittiMsg.s1ap_ue_context_release_req_log.size = res.result.encoded;
memcpy(&message_p->ittiMsg.s1ap_ue_context_release_req_log.text, res.buffer, res.result.encoded);
itti_send_msg_to_task(TASK_UNKNOWN, INSTANCE_DEFAULT, message_p);
free(res.buffer); free(res.buffer);
break; break;
@@ -166,63 +132,35 @@ int s1ap_eNB_encode_initiating(S1AP_S1AP_PDU_t *pdu,
static inline static inline
int s1ap_eNB_encode_successfull_outcome(S1AP_S1AP_PDU_t *pdu, int s1ap_eNB_encode_successfull_outcome(S1AP_S1AP_PDU_t *pdu,
uint8_t **buffer, uint32_t *len) uint8_t **buffer, uint32_t *len) {
{
MessageDef *message_p;
MessagesIds message_id;
asn_encode_to_new_buffer_result_t res = { NULL, {0, NULL, NULL} }; asn_encode_to_new_buffer_result_t res = { NULL, {0, NULL, NULL} };
DevAssert(pdu != NULL); DevAssert(pdu != NULL);
switch(pdu->choice.successfulOutcome.procedureCode) { switch(pdu->choice.successfulOutcome.procedureCode) {
case S1AP_ProcedureCode_id_InitialContextSetup: case S1AP_ProcedureCode_id_InitialContextSetup:
res = asn_encode_to_new_buffer(NULL, ATS_CANONICAL_XER, &asn_DEF_S1AP_S1AP_PDU, pdu); res = asn_encode_to_new_buffer(NULL, ATS_CANONICAL_XER, &asn_DEF_S1AP_S1AP_PDU, pdu);
message_id = S1AP_INITIAL_CONTEXT_SETUP_LOG;
message_p = itti_alloc_new_message_sized(TASK_S1AP, message_id, res.result.encoded + sizeof (IttiMsgText));
message_p->ittiMsg.s1ap_initial_context_setup_log.size = res.result.encoded;
memcpy(&message_p->ittiMsg.s1ap_initial_context_setup_log.text, res.buffer, res.result.encoded);
itti_send_msg_to_task(TASK_UNKNOWN, INSTANCE_DEFAULT, message_p);
free(res.buffer); free(res.buffer);
break; break;
case S1AP_ProcedureCode_id_UEContextRelease: case S1AP_ProcedureCode_id_UEContextRelease:
res = asn_encode_to_new_buffer(NULL, ATS_CANONICAL_XER, &asn_DEF_S1AP_S1AP_PDU, pdu); res = asn_encode_to_new_buffer(NULL, ATS_CANONICAL_XER, &asn_DEF_S1AP_S1AP_PDU, pdu);
message_id = S1AP_UE_CONTEXT_RELEASE_COMPLETE_LOG;
message_p = itti_alloc_new_message_sized(TASK_S1AP, message_id, res.result.encoded + sizeof (IttiMsgText));
message_p->ittiMsg.s1ap_ue_context_release_complete_log.size = res.result.encoded;
memcpy(&message_p->ittiMsg.s1ap_ue_context_release_complete_log.text, res.buffer, res.result.encoded);
itti_send_msg_to_task(TASK_UNKNOWN, INSTANCE_DEFAULT, message_p);
free(res.buffer); free(res.buffer);
break; break;
case S1AP_ProcedureCode_id_E_RABSetup: case S1AP_ProcedureCode_id_E_RABSetup:
res = asn_encode_to_new_buffer(NULL, ATS_CANONICAL_XER, &asn_DEF_S1AP_S1AP_PDU, pdu); res = asn_encode_to_new_buffer(NULL, ATS_CANONICAL_XER, &asn_DEF_S1AP_S1AP_PDU, pdu);
message_id = S1AP_E_RAB_SETUP_RESPONSE_LOG;
message_p = itti_alloc_new_message_sized(TASK_S1AP, message_id, res.result.encoded + sizeof (IttiMsgText));
message_p->ittiMsg.s1ap_e_rab_setup_response_log.size = res.result.encoded;
memcpy(&message_p->ittiMsg.s1ap_e_rab_setup_response_log.text, res.buffer, res.result.encoded);
itti_send_msg_to_task(TASK_UNKNOWN, INSTANCE_DEFAULT, message_p);
free(res.buffer); free(res.buffer);
S1AP_INFO("E_RABSetup successful message\n"); S1AP_INFO("E_RABSetup successful message\n");
break; break;
case S1AP_ProcedureCode_id_E_RABModify: case S1AP_ProcedureCode_id_E_RABModify:
res = asn_encode_to_new_buffer(NULL, ATS_CANONICAL_XER, &asn_DEF_S1AP_S1AP_PDU, pdu); res = asn_encode_to_new_buffer(NULL, ATS_CANONICAL_XER, &asn_DEF_S1AP_S1AP_PDU, pdu);
message_id = S1AP_E_RAB_MODIFY_RESPONSE_LOG;
message_p = itti_alloc_new_message_sized(TASK_S1AP, message_id, res.result.encoded + sizeof (IttiMsgText));
message_p->ittiMsg.s1ap_e_rab_modify_response_log.size = res.result.encoded;
memcpy(&message_p->ittiMsg.s1ap_e_rab_modify_response_log.text, res.buffer, res.result.encoded);
itti_send_msg_to_task(TASK_UNKNOWN, INSTANCE_DEFAULT, message_p);
free(res.buffer); free(res.buffer);
S1AP_INFO("E_RABModify successful message\n"); S1AP_INFO("E_RABModify successful message\n");
break; break;
case S1AP_ProcedureCode_id_E_RABRelease: case S1AP_ProcedureCode_id_E_RABRelease:
res = asn_encode_to_new_buffer(NULL, ATS_CANONICAL_XER, &asn_DEF_S1AP_S1AP_PDU, pdu); res = asn_encode_to_new_buffer(NULL, ATS_CANONICAL_XER, &asn_DEF_S1AP_S1AP_PDU, pdu);
message_id = S1AP_E_RAB_RELEASE_RESPONSE_LOG;
message_p = itti_alloc_new_message_sized(TASK_S1AP, message_id, res.result.encoded + sizeof (IttiMsgText));
message_p->ittiMsg.s1ap_e_rab_release_response_log.size = res.result.encoded;
memcpy(&message_p->ittiMsg.s1ap_e_rab_release_response_log.text, res.buffer, res.result.encoded);
itti_send_msg_to_task(TASK_UNKNOWN, INSTANCE_DEFAULT, message_p);
free(res.buffer); free(res.buffer);
S1AP_INFO("E_RAB Release successful message\n"); S1AP_INFO("E_RAB Release successful message\n");
break; break;
@@ -246,21 +184,13 @@ int s1ap_eNB_encode_successfull_outcome(S1AP_S1AP_PDU_t *pdu,
static inline static inline
int s1ap_eNB_encode_unsuccessfull_outcome(S1AP_S1AP_PDU_t *pdu, int s1ap_eNB_encode_unsuccessfull_outcome(S1AP_S1AP_PDU_t *pdu,
uint8_t **buffer, uint32_t *len) uint8_t **buffer, uint32_t *len) {
{
MessageDef *message_p;
MessagesIds message_id;
asn_encode_to_new_buffer_result_t res = { NULL, {0, NULL, NULL} }; asn_encode_to_new_buffer_result_t res = { NULL, {0, NULL, NULL} };
DevAssert(pdu != NULL); DevAssert(pdu != NULL);
switch(pdu->choice.unsuccessfulOutcome.procedureCode) { switch(pdu->choice.unsuccessfulOutcome.procedureCode) {
case S1AP_ProcedureCode_id_InitialContextSetup: case S1AP_ProcedureCode_id_InitialContextSetup:
res = asn_encode_to_new_buffer(NULL, ATS_CANONICAL_XER, &asn_DEF_S1AP_S1AP_PDU, pdu); res = asn_encode_to_new_buffer(NULL, ATS_CANONICAL_XER, &asn_DEF_S1AP_S1AP_PDU, pdu);
message_id = S1AP_INITIAL_CONTEXT_SETUP_LOG;
message_p = itti_alloc_new_message_sized(TASK_S1AP, message_id, res.result.encoded + sizeof (IttiMsgText));
message_p->ittiMsg.s1ap_initial_context_setup_log.size = res.result.encoded;
memcpy(&message_p->ittiMsg.s1ap_initial_context_setup_log.text, res.buffer, res.result.encoded);
itti_send_msg_to_task(TASK_UNKNOWN, INSTANCE_DEFAULT, message_p);
free(res.buffer); free(res.buffer);
break; break;
targets/COMMON/create_tasks.c
+6 -10
View File
@@ -50,15 +50,9 @@
# include "enb_app.h" # include "enb_app.h"
int create_tasks(uint32_t enb_nb) int create_tasks(uint32_t enb_nb) {
{
LOG_D(ENB_APP, "%s(enb_nb:%d\n", __FUNCTION__, enb_nb); LOG_D(ENB_APP, "%s(enb_nb:%d\n", __FUNCTION__, enb_nb);
itti_wait_ready(1); itti_wait_ready(1);
if (itti_create_task (TASK_L2L1, l2l1_task, NULL) < 0) {
LOG_E(PDCP, "Create task for L2L1 failed\n");
return -1;
}
if (enb_nb > 0) { if (enb_nb > 0) {
/* Last task to create, others task must be ready before its start */ /* Last task to create, others task must be ready before its start */
@@ -67,7 +61,9 @@ int create_tasks(uint32_t enb_nb)
return -1; return -1;
} }
} }
# if defined(ENABLE_USE_MME) # if defined(ENABLE_USE_MME)
if (EPC_MODE_ENABLED) { if (EPC_MODE_ENABLED) {
if (enb_nb > 0) { if (enb_nb > 0) {
if (itti_create_task (TASK_X2AP, x2ap_task, NULL) < 0) { if (itti_create_task (TASK_X2AP, x2ap_task, NULL) < 0) {
@@ -84,6 +80,7 @@ int create_tasks(uint32_t enb_nb)
LOG_E(S1AP, "Create task for S1AP failed\n"); LOG_E(S1AP, "Create task for S1AP failed\n");
return -1; return -1;
} }
if(!(get_softmodem_params()->emulate_rf)) { if(!(get_softmodem_params()->emulate_rf)) {
if (itti_create_task (TASK_UDP, udp_eNB_task, NULL) < 0) { if (itti_create_task (TASK_UDP, udp_eNB_task, NULL) < 0) {
LOG_E(UDP_, "Create task for UDP failed\n"); LOG_E(UDP_, "Create task for UDP failed\n");
@@ -96,9 +93,10 @@ int create_tasks(uint32_t enb_nb)
return -1; return -1;
} }
} }
} /* if (EPC_MODE_ENABLED) */ } /* if (EPC_MODE_ENABLED) */
#endif #endif
if (enb_nb > 0) { if (enb_nb > 0) {
LOG_I(RRC,"Creating RRC eNB Task\n"); LOG_I(RRC,"Creating RRC eNB Task\n");
@@ -108,9 +106,7 @@ int create_tasks(uint32_t enb_nb)
} }
} }
itti_wait_ready(0); itti_wait_ready(0);
return 0; return 0;
} }
#endif #endif
targets/COMMON/create_tasks_ue.c
+6 -11
View File
@@ -40,27 +40,25 @@
#endif #endif
# include "enb_app.h" # include "enb_app.h"
int create_tasks_ue(uint32_t ue_nb) int create_tasks_ue(uint32_t ue_nb) {
{
LOG_D(ENB_APP, "%s(ue_nb:%d)\n", __FUNCTION__, ue_nb); LOG_D(ENB_APP, "%s(ue_nb:%d)\n", __FUNCTION__, ue_nb);
itti_wait_ready(1); itti_wait_ready(1);
if (itti_create_task (TASK_L2L1, l2l1_task, NULL) < 0) {
LOG_E(PDCP, "Create task for L2L1 failed\n");
return -1;
}
# if defined(ENABLE_USE_MME) # if defined(ENABLE_USE_MME)
# if defined(NAS_BUILT_IN_UE) # if defined(NAS_BUILT_IN_UE)
if (ue_nb > 0) { if (ue_nb > 0) {
nas_user_container_t *users = calloc(1, sizeof(*users)); nas_user_container_t *users = calloc(1, sizeof(*users));
if (users == NULL) abort(); if (users == NULL) abort();
users->count = ue_nb; users->count = ue_nb;
if (itti_create_task (TASK_NAS_UE, nas_ue_task, users) < 0) { if (itti_create_task (TASK_NAS_UE, nas_ue_task, users) < 0) {
LOG_E(NAS, "Create task for NAS UE failed\n"); LOG_E(NAS, "Create task for NAS UE failed\n");
return -1; return -1;
} }
} }
# endif # endif
# endif # endif
@@ -69,12 +67,9 @@ int create_tasks_ue(uint32_t ue_nb)
LOG_E(RRC, "Create task for RRC UE failed\n"); LOG_E(RRC, "Create task for RRC UE failed\n");
return -1; return -1;
} }
} }
itti_wait_ready(0); itti_wait_ready(0);
return 0; return 0;
} }
#endif #endif
targets/RT/USER/lte-softmodem.c
+1 -67
View File
@@ -127,10 +127,7 @@ int config_sync_var=-1;
uint16_t runtime_phy_rx[29][6]; // SISO [MCS 0-28][RBs 0-5 : 6, 15, 25, 50, 75, 100] uint16_t runtime_phy_rx[29][6]; // SISO [MCS 0-28][RBs 0-5 : 6, 15, 25, 50, 75, 100]
uint16_t runtime_phy_tx[29][6]; // SISO [MCS 0-28][RBs 0-5 : 6, 15, 25, 50, 75, 100] uint16_t runtime_phy_tx[29][6]; // SISO [MCS 0-28][RBs 0-5 : 6, 15, 25, 50, 75, 100]
#if defined(ENABLE_ITTI)
volatile int start_eNB = 0;
volatile int start_UE = 0;
#endif
volatile int oai_exit = 0; volatile int oai_exit = 0;
uint32_t downlink_frequency[MAX_NUM_CCs][4]; uint32_t downlink_frequency[MAX_NUM_CCs][4];
@@ -382,61 +379,6 @@ static void *scope_thread(void *arg) {
#endif #endif
#if defined(ENABLE_ITTI)
void *l2l1_task(void *arg) {
MessageDef *message_p = NULL;
int result;
itti_set_task_real_time(TASK_L2L1);
itti_mark_task_ready(TASK_L2L1);
/* Wait for the initialize message */
printf("Wait for the ITTI initialize message\n");
while (1) {
itti_receive_msg (TASK_L2L1, &message_p);
switch (ITTI_MSG_ID(message_p)) {
case INITIALIZE_MESSAGE:
/* Start eNB thread */
LOG_D(PHY, "L2L1 TASK received %s\n", ITTI_MSG_NAME(message_p));
start_eNB = 1;
break;
case TERMINATE_MESSAGE:
LOG_W(PHY, " *** Exiting L2L1 thread\n");
oai_exit=1;
start_eNB = 0;
itti_exit_task ();
break;
case ACTIVATE_MESSAGE:
start_UE = 1;
break;
case DEACTIVATE_MESSAGE:
start_UE = 0;
break;
case MESSAGE_TEST:
printf("Received %s\n", ITTI_MSG_NAME(message_p));
break;
default:
printf("Received unexpected message %s\n", ITTI_MSG_NAME(message_p));
break;
}
result = itti_free (ITTI_MSG_ORIGIN_ID(message_p), message_p);
AssertFatal (result == EXIT_SUCCESS, "Failed to free memory (%d)!\n", result);
message_p = NULL;
};
return NULL;
}
#endif
static void get_options(void) { static void get_options(void) {
CONFIG_SETRTFLAG(CONFIG_NOEXITONHELP); CONFIG_SETRTFLAG(CONFIG_NOEXITONHELP);
get_common_options(); get_common_options();
@@ -567,7 +509,6 @@ int stop_L1L2(module_id_t enb_id) {
/* these tasks need to pick up new configuration */ /* these tasks need to pick up new configuration */
terminate_task(enb_id, TASK_ENB_APP, TASK_RRC_ENB); terminate_task(enb_id, TASK_ENB_APP, TASK_RRC_ENB);
terminate_task(enb_id, TASK_ENB_APP, TASK_L2L1);
oai_exit = 1; oai_exit = 1;
LOG_I(ENB_APP, "calling kill_RU_proc() for instance %d\n", enb_id); LOG_I(ENB_APP, "calling kill_RU_proc() for instance %d\n", enb_id);
kill_RU_proc(RC.ru[enb_id]); kill_RU_proc(RC.ru[enb_id]);
@@ -619,13 +560,6 @@ int restart_L1L2(module_id_t enb_id) {
LOG_I(RRC, "Re-created task for RRC eNB successfully\n"); LOG_I(RRC, "Re-created task for RRC eNB successfully\n");
} }
if (itti_create_task (TASK_L2L1, l2l1_task, NULL) < 0) {
LOG_E(PDCP, "Create task for L2L1 failed\n");
return -1;
} else {
LOG_I(PDCP, "Re-created task for L2L1 successfully\n");
}
/* pass a reconfiguration request which will configure everything down to /* pass a reconfiguration request which will configure everything down to
* RC.eNB[i][j]->frame_parms, too */ * RC.eNB[i][j]->frame_parms, too */
msg_p = itti_alloc_new_message(TASK_ENB_APP, RRC_CONFIGURATION_REQ); msg_p = itti_alloc_new_message(TASK_ENB_APP, RRC_CONFIGURATION_REQ);
targets/RT/USER/lte-softmodem.h
+2 -9
View File
@@ -290,14 +290,6 @@ extern int sync_var;
extern int transmission_mode; extern int transmission_mode;
extern double cpuf; extern double cpuf;
#if defined(ENABLE_ITTI)
extern volatile int start_eNB;
extern volatile int start_UE;
#endif
// In lte-enb.c // In lte-enb.c
extern void init_eNB(int single_thread_flag,int wait_for_sync); extern void init_eNB(int single_thread_flag,int wait_for_sync);
extern void stop_eNB(int); extern void stop_eNB(int);
@@ -315,7 +307,8 @@ extern void set_function_spec_param(RU_t *ru);
extern int setup_ue_buffers(PHY_VARS_UE **phy_vars_ue, openair0_config_t *openair0_cfg); extern int setup_ue_buffers(PHY_VARS_UE **phy_vars_ue, openair0_config_t *openair0_cfg);
extern void fill_ue_band_info(void); extern void fill_ue_band_info(void);
extern void init_UE(int nb_inst,int eMBMS_active, int uecap_xer_in, int timing_correction, int phy_test, int UE_scan, int UE_scan_carrier, runmode_t mode,int rxgain,int txpowermax, LTE_DL_FRAME_PARMS *fp); extern void init_UE(int nb_inst,int eMBMS_active, int uecap_xer_in, int timing_correction, int phy_test, int UE_scan, int UE_scan_carrier, runmode_t mode,int rxgain,int txpowermax,
LTE_DL_FRAME_PARMS *fp);
extern void init_thread(int sched_runtime, int sched_deadline, int sched_fifo, cpu_set_t *cpuset, char *name); extern void init_thread(int sched_runtime, int sched_deadline, int sched_fifo, cpu_set_t *cpuset, char *name);
extern void reset_opp_meas(void); extern void reset_opp_meas(void);
targets/RT/USER/lte-uesoftmodem.c
-46
View File
@@ -124,10 +124,6 @@ int config_sync_var=-1;
uint16_t runtime_phy_rx[29][6]; // SISO [MCS 0-28][RBs 0-5 : 6, 15, 25, 50, 75, 100] uint16_t runtime_phy_rx[29][6]; // SISO [MCS 0-28][RBs 0-5 : 6, 15, 25, 50, 75, 100]
uint16_t runtime_phy_tx[29][6]; // SISO [MCS 0-28][RBs 0-5 : 6, 15, 25, 50, 75, 100] uint16_t runtime_phy_tx[29][6]; // SISO [MCS 0-28][RBs 0-5 : 6, 15, 25, 50, 75, 100]
#if defined(ENABLE_ITTI)
volatile int start_eNB = 0;
volatile int start_UE = 0;
#endif
volatile int oai_exit = 0; volatile int oai_exit = 0;
clock_source_t clock_source = internal; clock_source_t clock_source = internal;
@@ -398,48 +394,6 @@ static void *scope_thread(void *arg) {
#if defined(ENABLE_ITTI)
void *l2l1_task(void *arg) {
MessageDef *message_p = NULL;
int result;
itti_set_task_real_time(TASK_L2L1);
itti_mark_task_ready(TASK_L2L1);
do {
// Wait for a message
itti_receive_msg (TASK_L2L1, &message_p);
switch (ITTI_MSG_ID(message_p)) {
case TERMINATE_MESSAGE:
oai_exit=1;
itti_exit_task ();
break;
case ACTIVATE_MESSAGE:
start_UE = 1;
break;
case DEACTIVATE_MESSAGE:
start_UE = 0;
break;
case MESSAGE_TEST:
LOG_I(SIM, "Received %s\n", ITTI_MSG_NAME(message_p));
break;
default:
LOG_E(SIM, "Received unexpected message %s\n", ITTI_MSG_NAME(message_p));
break;
}
result = itti_free (ITTI_MSG_ORIGIN_ID(message_p), message_p);
AssertFatal (result == EXIT_SUCCESS, "Failed to free memory (%d)!\n", result);
} while(!oai_exit);
return NULL;
}
#endif
extern int16_t dlsch_demod_shift; extern int16_t dlsch_demod_shift;
static void get_options(void) { static void get_options(void) {