Merge remote-tracking branch 'origin/bugfix-189-rlc-am-fixes' into develop_integration_w13

openair2/COMMON/mac_rrc_primitives.h

@@ -388,9 +388,9 @@ typedef struct {
                             struct PMCH_InfoList_r9 *pmch_InfoList
 #endif
                            );
-  unsigned int (*mac_rlc_data_req)(module_id_t, unsigned int, char*);
+  unsigned int (*mac_rlc_data_req)(module_id_t, unsigned int, const unsigned int,char*);
   void (*mac_rlc_data_ind)(module_id_t, logical_chan_id_t, char*, tb_size_t, num_tb_t, crc_t* );
-  mac_rlc_status_resp_t (*mac_rlc_status_ind)     (module_id_t enb_mod_idP, module_id_t ue_mod_idP, frame_t frameP, eNB_flag_t eNB_flagP, MBMS_flag_t MBMS_flagP,
+  mac_rlc_status_resp_t (*mac_rlc_status_ind)     (module_id_t enb_mod_idP, module_id_t ue_mod_idP, frame_t frameP, sub_frame_t subframeP, eNB_flag_t eNB_flagP, MBMS_flag_t MBMS_flagP,
       logical_chan_id_t channel_idP, tb_size_t tb_sizeP);
   signed int (*rrc_rlc_data_req)(module_id_t, rb_id_t, mui_t, confirm_t, sdu_size_t, char *);
   void (*rrc_rlc_register_rrc) (void (*rrc_data_indP)(module_id_t , rb_id_t , sdu_size_t , char* ),

openair2/ENB_APP/flexran_agent_common.c

@@ -562,14 +562,16 @@ int flexran_get_ue_wcqi (mid_t mod_id, mid_t ue_id) {
 int flexran_get_tx_queue_size(mid_t mod_id, mid_t ue_id, logical_chan_id_t channel_id) {
   rnti_t rnti = flexran_get_ue_crnti(mod_id,ue_id);
   uint16_t frame = (uint16_t) flexran_get_current_frame(mod_id);
-  mac_rlc_status_resp_t rlc_status = mac_rlc_status_ind(mod_id,rnti, mod_id,frame,ENB_FLAG_YES,MBMS_FLAG_NO, channel_id, 0);
+  uint16_t subframe = (uint16_t) flexran_get_current_subframe(mod_id);
+  mac_rlc_status_resp_t rlc_status = mac_rlc_status_ind(mod_id,rnti, mod_id,frame,subframe,ENB_FLAG_YES,MBMS_FLAG_NO, channel_id, 0);
   return rlc_status.bytes_in_buffer;
 }
 
 int flexran_get_hol_delay(mid_t mod_id, mid_t ue_id, logical_chan_id_t channel_id) {
   rnti_t rnti = flexran_get_ue_crnti(mod_id,ue_id);
   uint16_t frame = (uint16_t) flexran_get_current_frame(mod_id);
-  mac_rlc_status_resp_t rlc_status = mac_rlc_status_ind(mod_id, rnti, mod_id, frame, ENB_FLAG_YES, MBMS_FLAG_NO, channel_id, 0);
+  uint16_t subframe = (uint16_t) flexran_get_current_subframe(mod_id);
+  mac_rlc_status_resp_t rlc_status = mac_rlc_status_ind(mod_id, rnti, mod_id, frame, subframe, ENB_FLAG_YES, MBMS_FLAG_NO, channel_id, 0);
   return rlc_status.head_sdu_creation_time;
 }
 

openair2/LAYER2/MAC/eNB_scheduler_mch.c

@@ -504,7 +504,7 @@ int schedule_MBMS(module_id_t module_idP, uint8_t CC_id, frame_t frameP, sub_fra
           module_idP,CC_id,frameP,MTCH,TBS,
           TBS-header_len_mcch-header_len_msi-sdu_length_total-header_len_mtch);
 
-    rlc_status = mac_rlc_status_ind(module_idP,0,frameP,module_idP,ENB_FLAG_YES,MBMS_FLAG_YES,MTCH,
+    rlc_status = mac_rlc_status_ind(module_idP,0,frameP,subframeP,module_idP,ENB_FLAG_YES,MBMS_FLAG_YES,MTCH,
                                     TBS-header_len_mcch-header_len_msi-sdu_length_total-header_len_mtch);
     LOG_D(MAC,"e-MBMS log channel %u frameP %d, subframeP %d,  rlc_status.bytes_in_buffer is %d\n",
           MTCH,frameP,subframeP, rlc_status.bytes_in_buffer);
@@ -521,6 +521,7 @@ int schedule_MBMS(module_id_t module_idP, uint8_t CC_id, frame_t frameP, sub_fra
                                 ENB_FLAG_YES,
                                 MBMS_FLAG_YES,
                                 MTCH,
+								0,	//not used
                                 (char*)&mch_buffer[sdu_length_total]);
       //sdu_lengths[num_sdus] = mac_rlc_data_req(module_idP,frameP, MBMS_FLAG_NO,  MTCH+(MAX_NUM_RB*(NUMBER_OF_UE_MAX+1)), (char*)&mch_buffer[sdu_length_total]);
       LOG_I(MAC,"[eNB %d][MBMS USER-PLANE] CC_id %d Got %d bytes for MTCH %d\n",module_idP,CC_id,sdu_lengths[num_sdus],MTCH);

openair2/LAYER2/MAC/flexran_agent_scheduler_dataplane.c

@@ -174,6 +174,7 @@ void flexran_apply_ue_spec_scheduling_decisions(mid_t mod_id,
 	   				  rnti,
 	   				  mod_id,
 	   				  frame,
+					  subframe,
 	   				  ENB_FLAG_YES,
 	   				  MBMS_FLAG_NO,
 	   				  lcid,
@@ -193,6 +194,7 @@ void flexran_apply_ue_spec_scheduling_decisions(mid_t mod_id,
 					    rnti,
 					    mod_id,
 					    frame,
+						subframe,
 					    ENB_FLAG_YES,
 					    MBMS_FLAG_NO,
 					    lcid,
@@ -209,6 +211,7 @@ void flexran_apply_ue_spec_scheduling_decisions(mid_t mod_id,
 						ENB_FLAG_YES,
 						MBMS_FLAG_NO,
 						lcid,
+						rlc_size, //not used
 						(char *)&dlsch_buffer[sdu_length_total]);
 	      
 	      LOG_D(MAC,"[eNB %d][LCID %d] CC_id %d Got %d bytes from RLC\n",mod_id, lcid, CC_id, sdu_lengths[j]);

openair2/LAYER2/MAC/flexran_agent_scheduler_dlsch_ue.c

@@ -160,7 +160,7 @@ void _store_dlsch_buffer (module_id_t Mod_id,
 
     for(i=0; i< MAX_NUM_LCID; i++) { // loop over all the logical channels
 
-      rlc_status = mac_rlc_status_ind(Mod_id,rnti, Mod_id,frameP,ENB_FLAG_YES,MBMS_FLAG_NO,i,0 );
+      rlc_status = mac_rlc_status_ind(Mod_id,rnti, Mod_id,frameP,subframeP,ENB_FLAG_YES,MBMS_FLAG_NO,i,0 );
       UE_template->dl_buffer_info[i] = rlc_status.bytes_in_buffer; //storing the dlsch buffer for each logical channel
       UE_template->dl_pdus_in_buffer[i] = rlc_status.pdus_in_buffer;
       UE_template->dl_buffer_head_sdu_creation_time[i] = rlc_status.head_sdu_creation_time ;
@@ -1241,6 +1241,7 @@ flexran_schedule_ue_spec_common(mid_t   mod_id,
 					     rnti,
 					     mod_id,
 					     frame,
+						 subframe,
 					     ENB_FLAG_YES,
 					     MBMS_FLAG_NO,
 					     j,

openair2/LAYER2/MAC/pre_processor.c

@@ -109,7 +109,7 @@ void store_dlsch_buffer (module_id_t Mod_id,
 
     for(i=0; i< MAX_NUM_LCID; i++) { // loop over all the logical channels
 
-      rlc_status = mac_rlc_status_ind(Mod_id,rnti, Mod_id,frameP,ENB_FLAG_YES,MBMS_FLAG_NO,i,0 );
+      rlc_status = mac_rlc_status_ind(Mod_id,rnti, Mod_id,frameP,subframeP,ENB_FLAG_YES,MBMS_FLAG_NO,i,0 );
       UE_template->dl_buffer_info[i] = rlc_status.bytes_in_buffer; //storing the dlsch buffer for each logical channel
       UE_template->dl_pdus_in_buffer[i] = rlc_status.pdus_in_buffer;
       UE_template->dl_buffer_head_sdu_creation_time[i] = rlc_status.head_sdu_creation_time ;

openair2/LAYER2/MAC/ra_procedures.c

@@ -394,7 +394,7 @@ PRACH_RESOURCES_t *ue_get_rach(module_id_t module_idP,int CC_id,frame_t frameP,
         } else if (UE_mac_inst[module_idP].scheduling_info.BSR_bytes[UE_mac_inst[module_idP].scheduling_info.LCGID[DCCH]] > 0) {
           // This is for triggering a transmission on DCCH using PRACH (during handover, or sending SR for example)
           dcch_header_len = 2 + 2;  /// SHORT Subheader + C-RNTI control element
-          rlc_status = mac_rlc_status_ind(module_idP,UE_mac_inst[module_idP].crnti, eNB_indexP,frameP,ENB_FLAG_NO,MBMS_FLAG_NO,
+          rlc_status = mac_rlc_status_ind(module_idP,UE_mac_inst[module_idP].crnti, eNB_indexP,frameP,subframeP,ENB_FLAG_NO,MBMS_FLAG_NO,
                                           DCCH,
                                           6);
 
@@ -409,6 +409,7 @@ PRACH_RESOURCES_t *ue_get_rach(module_id_t module_idP,int CC_id,frame_t frameP,
           sdu_lengths[0] = mac_rlc_data_req(module_idP, UE_mac_inst[module_idP].crnti,
                                             eNB_indexP, frameP,ENB_FLAG_NO, MBMS_FLAG_NO,
                                             DCCH,
+											6,	//not used
                                             (char *)&ulsch_buff[0]);
 
           LOG_D(MAC,"[UE %d] TX Got %d bytes for DCCH\n",module_idP,sdu_lengths[0]);

openair2/LAYER2/RLC/AM_v9.3.0/rlc_am.h

@@ -267,23 +267,32 @@ private_rlc_am(   void     rlc_am_get_pdus (const protocol_ctxt_t* const ctxtP,v
 */
 protected_rlc_am( void     rlc_am_rx (const protocol_ctxt_t* const ctxtP,void * const rlc_pP, struct mac_data_ind);)
 
-/*! \fn struct mac_status_resp rlc_am_mac_status_indication (const protocol_ctxt_t* const ctxtP,void * const rlc_pP, uint16_t tbs_sizeP, struct mac_status_ind tx_statusP)
+/*! \fn struct mac_status_resp rlc_am_mac_status_indication (const protocol_ctxt_t* const ctxtP,void * const rlc_pP, uint16_t tbs_sizeP, struct mac_status_ind tx_statusP,const eNB_flag_t enb_flagP)
 * \brief    Request the maximum number of bytes that can be served by RLC instance to MAC and fix the amount of bytes requested by MAC for next RLC transmission.
 * \param[in]  ctxt_pP          Running context.
 * \param[in]  rlc_pP           RLC AM protocol instance pointer.
 * \param[in]  tbs_sizeP                 Number of bytes requested by MAC for next transmission.
 * \param[in]  tx_statusP                Transmission status given by MAC on previous MAC transmission of the PDU.
+* \param[in]  enb_flagP        eNB or UE flag indication.
 * \return     The maximum number of bytes that can be served by RLC instance to MAC.
 */
-public_rlc_am(    struct mac_status_resp rlc_am_mac_status_indication (const protocol_ctxt_t* const ctxtP, void * const rlc_pP, uint16_t tbs_sizeP, struct mac_status_ind tx_statusP);)
+public_rlc_am(    struct mac_status_resp rlc_am_mac_status_indication (const protocol_ctxt_t* const ctxtP, void * const rlc_pP, uint16_t tbs_sizeP, struct mac_status_ind tx_statusP,const eNB_flag_t enb_flagP);)
 
-/*! \fn struct mac_data_req rlc_am_mac_data_request (const protocol_ctxt_t* const ctxtP,void * const rlc_pP)
+/*! \fn void rlc_am_set_nb_bytes_requested_by_mac (void * const            rlc_pP,const tb_size_t         tb_sizeP)
+* \brief    Set available TBS for RLC Tx just before am_mac_data_request. Used for UE only.
+* \param[in]  rlc_pP           RLC AM protocol instance pointer.
+* \param[in]  tb_sizeP         Available Tx Transport Block size in bytes.
+*/
+public_rlc_am(		void rlc_am_set_nb_bytes_requested_by_mac (void * const            rlc_pP,const tb_size_t         tb_sizeP);)
+
+/*! \fn struct mac_data_req rlc_am_mac_data_request (const protocol_ctxt_t* const ctxtP,void * const rlc_pP,const eNB_flag_t   enb_flagP)
 * \brief    Gives PDUs to lower layer MAC.
 * \param[in]  ctxt_pP          Running context.
 * \param[in]  rlc_pP           RLC AM protocol instance pointer.
+* \param[in]  enb_flagP        eNB or UE flag
 * \return     A PDU of the previously requested number of bytes, and the updated maximum number of bytes that can be served by RLC instance to MAC for next RLC transmission.
 */
-public_rlc_am(    struct mac_data_req rlc_am_mac_data_request (const protocol_ctxt_t* const ctxtP,void * const rlc_pP);)
+public_rlc_am(    struct mac_data_req rlc_am_mac_data_request (const protocol_ctxt_t* const ctxtP,void * const rlc_pP,const eNB_flag_t  enb_flagP);)
 
 /*! \fn void     rlc_am_mac_data_indication (const protocol_ctxt_t* const ctxtP,void * const rlc_pP, struct mac_data_ind data_indP)
 * \brief    Receive PDUs from lower layer MAC.
@@ -293,6 +302,13 @@ public_rlc_am(    struct mac_data_req rlc_am_mac_data_request (const protocol_ct
 */
 public_rlc_am(    void     rlc_am_mac_data_indication (const protocol_ctxt_t* const ctxtP,void * const rlc_pP, struct mac_data_ind data_indP);)
 
+/*! \fn uint32_t rlc_am_get_buffer_occupancy_in_bytes (const protocol_ctxt_t* const ctxt_pP, rlc_am_entity_t * const      rlc_pP)
+* \brief   Get Tx Buffer Occupancy.
+* \param[in]  ctxt_pP          Running context.
+* \param[in]  rlc_pP           RLC AM protocol instance pointer.
+*/
+public_rlc_am(    uint32_t rlc_am_get_buffer_occupancy_in_bytes (const protocol_ctxt_t* const ctxt_pP, rlc_am_entity_t * const      rlc_pP);)
+
 /*! \fn void     rlc_am_data_req (const protocol_ctxt_t* const ctxtP,void * const rlc_pP, mem_block_t *sduP)
 * \brief    Interface with higher layers, buffer higher layer SDUS for transmission.
 * \param[in]  ctxt_pP          Running context.

openair2/LAYER2/RLC/AM_v9.3.0/rlc_am_constants.h

@@ -48,14 +48,17 @@
 #    define RLC_AM_SDU_DATA_BUFFER_SIZE           64*1024
 
 /** Max number of incoming SDUs from upper layer that can be buffered in a RLC AM protocol instance. */
-#    define RLC_AM_SDU_CONTROL_BUFFER_SIZE        128
+#    define RLC_AM_SDU_CONTROL_BUFFER_SIZE        1024
 
 /** Size of the retransmission buffer (number of PDUs). */
-#    define RLC_AM_PDU_RETRANSMISSION_BUFFER_SIZE RLC_AM_SN_MODULO
+#    define RLC_AM_PDU_RETRANSMISSION_BUFFER_SIZE RLC_AM_WINDOW_SIZE
 
 /** PDU minimal header size in bytes. */
 #    define RLC_AM_HEADER_MIN_SIZE                2
 
+/** PDU Segment minimal header size in bytes = PDU header + SOStart + SOEnd. */
+#    define RLC_AM_PDU_SEGMENT_HEADER_MIN_SIZE    4
+
 /** If we want to send a segment of a PDU, then the min transport block size requested by MAC should be this amount. */
 #    define RLC_AM_MIN_SEGMENT_SIZE_REQUEST       8
 
@@ -69,6 +72,99 @@
 #    define RLC_AM_MAX_NACK_IN_STATUS_PDU         1023
 
 /** Max holes created by NACK_SN with segment offsets for a PDU in the retransmission buffer. */
-#    define RLC_AM_MAX_HOLES_REPORT_PER_PDU       32
+#    define RLC_AM_MAX_HOLES_REPORT_PER_PDU       16
 /** @} */
-#    endif
+
+#define	RLC_AM_POLL_PDU_INFINITE				0xFFFF
+#define	RLC_AM_POLL_BYTE_INFINITE				0xFFFFFFFF
+
+/* MACRO DEFINITIONS */
+
+#define RLC_AM_NEXT_SN(sn)         (((sn)+1) & (RLC_AM_SN_MASK))
+#define RLC_AM_PREV_SN(sn)         (((sn)+(RLC_AM_SN_MODULO)-1) & (RLC_AM_SN_MASK))
+
+#define RLC_DIFF_SN(sn,snref,modulus)  ((sn+(modulus)-snref) & ((modulus)-1))
+#define RLC_SN_IN_WINDOW(sn,snref,modulus)  ((RLC_DIFF_SN(sn,snref,modulus)) < ((modulus) >> 1))
+
+#define RLC_AM_DIFF_SN(sn,snref)       (RLC_DIFF_SN(sn,snref,RLC_AM_SN_MODULO))
+#define RLC_AM_SN_IN_WINDOW(sn,snref)  (RLC_SN_IN_WINDOW(sn,snref,RLC_AM_SN_MODULO))
+
+#define RLC_SET_BIT(x,offset)      ((x) |= (1 << (offset)))
+#define RLC_GET_BIT(x,offset)      (((x) & (1 << (offset))) >> (offset))
+#define RLC_CLEAR_BIT(x,offset)    ((x) &= ~(1 << (offset)))
+
+#define RLC_SET_EVENT(x,event)         ((x) |= (event))
+#define RLC_GET_EVENT(x,event)         ((x) & (event))
+#define RLC_CLEAR_EVENT(x,event)       ((x) &= (~(event)))
+
+/* Common to Data and Status PDU */
+#define RLC_AM_SN_BITS				10
+#define RLC_AM_PDU_D_C_BITS          1
+#define RLC_AM_PDU_E_BITS            1
+#define RLC_AM_PDU_FI_BITS           2
+#define RLC_AM_PDU_POLL_BITS         1
+#define RLC_AM_PDU_RF_BITS           1
+
+
+#define RLC_AM_LI_BITS				11
+#define RLC_AM_LI_MASK				0x7FF
+
+
+/* AM Data PDU */
+#define RLC_AM_PDU_E_OFFSET                2
+#define RLC_AM_PDU_FI_OFFSET               (RLC_AM_PDU_E_OFFSET + RLC_AM_PDU_E_BITS)
+#define RLC_AM_PDU_POLL_OFFSET             (RLC_AM_PDU_FI_OFFSET + RLC_AM_PDU_FI_BITS)
+#define RLC_AM_PDU_RF_OFFSET               (RLC_AM_PDU_POLL_OFFSET + RLC_AM_PDU_POLL_BITS)
+#define RLC_AM_PDU_D_C_OFFSET              (RLC_AM_PDU_RF_OFFSET + RLC_AM_PDU_RF_BITS)
+
+#define RLC_AM_PDU_GET_FI_START(px)       (RLC_GET_BIT((px),RLC_AM_PDU_FI_OFFSET + 1))
+#define RLC_AM_PDU_GET_FI_END(px)       (RLC_GET_BIT((px),RLC_AM_PDU_FI_OFFSET))
+
+#define RLC_AM_PDU_GET_LI(x,offset)       (((x) >> (offset)) & RLC_AM_LI_MASK)
+#define RLC_AM_PDU_SET_LI(x,li,offset)       ((x) |= (((li) & RLC_AM_LI_MASK) << (offset)))
+
+#define RLC_AM_PDU_SET_E(px)      	(RLC_SET_BIT((px),RLC_AM_PDU_E_OFFSET))
+#define RLC_AM_PDU_SET_D_C(px)      (RLC_SET_BIT((px),RLC_AM_PDU_D_C_OFFSET))
+#define RLC_AM_PDU_SET_RF(px)       (RLC_SET_BIT((px),RLC_AM_PDU_RF_OFFSET))
+#define RLC_AM_PDU_SET_POLL(px)     (RLC_SET_BIT((px),RLC_AM_PDU_POLL_OFFSET))
+#define RLC_AM_PDU_CLEAR_POLL(px)   (RLC_CLEAR_BIT((px),RLC_AM_PDU_POLL_OFFSET))
+
+#define RLC_AM_PDU_SEGMENT_SO_LENGTH       15
+#define RLC_AM_PDU_SEGMENT_SO_BYTES        2
+#define RLC_AM_PDU_SEGMENT_SO_OFFSET       0
+#define RLC_AM_PDU_LSF_OFFSET              (RLC_AM_PDU_SEGMENT_SO_OFFSET + RLC_AM_PDU_SEGMENT_SO_LENGTH)
+
+#define RLC_AM_PDU_SET_LSF(px)      	(RLC_SET_BIT((px),RLC_AM_PDU_LSF_OFFSET))
+
+#define RLC_AM_HEADER_LI_LENGTH(li)          ((li) + ((li)>>1) + ((li)&1))
+#define RLC_AM_PDU_SEGMENT_HEADER_SIZE(numLis) (RLC_AM_PDU_SEGMENT_HEADER_MIN_SIZE + RLC_AM_HEADER_LI_LENGTH(numLis))
+
+/* STATUS PDU */
+#define RLC_AM_STATUS_PDU_CPT_STATUS           0
+
+#define RLC_AM_STATUS_PDU_CPT_OFFSET           4
+#define RLC_AM_STATUS_PDU_CPT_LENGTH           3
+
+#define RLC_AM_STATUS_PDU_ACK_SN_OFFSET        2
+
+#define RLC_AM_STATUS_PDU_SO_LENGTH            15
+
+#define RLC_AM_STATUS_PDU_SO_END_ALL_BYTES     0x7FFF
+
+
+/* Uplink STATUS PDU trigger events */
+#define RLC_AM_STATUS_NOT_TRIGGERED               0
+#define RLC_AM_STATUS_TRIGGERED_POLL              0x01    /* Status Report is triggered by a received poll */
+#define RLC_AM_STATUS_TRIGGERED_T_REORDERING      0x02    /* Status Report is triggered by Timer Reordering Expiry */
+#define RLC_AM_STATUS_TRIGGERED_DELAYED           0x10    /* Status is delayed until SN(receivedPoll) < VR(MS) */
+#define RLC_AM_STATUS_PROHIBIT                    0x20    /* TimerStatusProhibit still running */
+#define RLC_AM_STATUS_NO_TX_MASK				  (RLC_AM_STATUS_PROHIBIT | RLC_AM_STATUS_TRIGGERED_DELAYED)
+
+/* Status triggered (bit 5-7) will be concatenated with Poll triggered (bit 0-4) for RLCdec. RLC_AM_STATUS_TRIGGERED_DELAYED is not recorded. */
+#define RLC_AM_SET_STATUS(x,event)     (RLC_SET_EVENT(x,event))
+#define RLC_AM_GET_STATUS(x,event)     (RLC_GET_EVENT(x,event))
+#define RLC_AM_CLEAR_STATUS(x,event)   (RLC_CLEAR_EVENT(x,event))
+#define RLC_AM_CLEAR_ALL_STATUS(x)     ((x) = (RLC_AM_STATUS_NOT_TRIGGERED))
+
+
+#endif

openair2/LAYER2/RLC/AM_v9.3.0/rlc_am_entity.h

@@ -57,7 +57,6 @@ typedef struct rlc_am_entity_s {
   boolean_t         is_data_plane;                      /*!< \brief To know if the RLC belongs to a data radio bearer or a signalling radio bearer, for statistics and trace purpose. */
 
   rlc_buffer_occupancy_t sdu_buffer_occupancy;               /*!< \brief Number of bytes of unsegmented SDUs. */
-  rlc_buffer_occupancy_t retransmission_buffer_occupancy;    /*!< \brief Number of bytes of PDUs in retransmission buffer waiting for a ACK. */
   rlc_buffer_occupancy_t status_buffer_occupancy;            /*!< \brief Number of bytes of control PDUs waiting for transmission. */
 
   rlc_am_control_pdu_info_t  control_pdu_info;
@@ -69,17 +68,14 @@ typedef struct rlc_am_entity_s {
   pthread_mutex_t      lock_input_sdus;
   rlc_am_tx_sdu_management_t   *input_sdus;           /*!< \brief Input SDU buffer (for SDUs coming from upper layers). */
   signed int      nb_sdu;                             /*!< \brief Total number of valid rlc_am_tx_sdu_management_t in input_sdus[]. */
-  signed int      nb_sdu_no_segmented;                /*!< \brief Total number of SDUs not segmented and partially segmented. */
+  signed int      nb_sdu_no_segmented;                /*!< \brief Total number of SDUs not segmented and partially segmented. nb_sdu_no_segmented = next_sdu_index - current_sdu_index */
   signed int      next_sdu_index;                     /*!< \brief Next SDU index in input_sdus array where for a new incoming SDU. */
-  signed int      current_sdu_index;                  /*!< \brief Current SDU index in input_sdus array to be segmented. */
+  signed int      current_sdu_index;                  /*!< \brief Current SDU index in input_sdus array to be segmented which is not segmented or partially segmented. */
 
 
-  rlc_am_tx_data_pdu_management_t *pdu_retrans_buffer;       /*!< \brief Retransmission buffer. */
+  rlc_am_tx_data_pdu_management_t *tx_data_pdu_buffer;       /*!< \brief Transmission PDU data buffer. Used also for retransmissions */
   signed int      retrans_num_pdus;                          /*!< \brief Number of PDUs in the retransmission buffer. */
-  signed int      retrans_num_bytes;                         /*!< \brief Number of bytes in the retransmission buffer. */
-  signed int      retrans_num_bytes_to_retransmit;           /*!< \brief Number of bytes in the retransmission buffer to be retransmitted. */
-  unsigned int    num_nack_so;                               /*!< \brief Number of segment offsets asked to be retransmitted by peer RLC entity. */
-  unsigned int    num_nack_sn;                               /*!< \brief Number of segment asked to be retransmitted by peer RLC entity. */
+  signed int      retrans_num_bytes_to_retransmit;           /*!< \brief Number of bytes in the retransmission buffer to be retransmitted. Only payload is taken into account */
   boolean_t       force_poll;                                /*!< \brief force poll due to t_poll_retransmit time-out. */
 
   //---------------------------------------------------------------------
@@ -137,7 +133,7 @@ typedef struct rlc_am_entity_s {
   //-----------------------------
   uint16_t           max_retx_threshold; /*!< \brief This parameter is used by the transmitting side of each AM RLC entity to limit the number of retransmissions of an AMD PDU. */
   uint16_t           poll_pdu;           /*!< \brief This parameter is used by the transmitting side of each AM RLC entity to trigger a poll for every pollPDU PDUs. */
-  uint16_t           poll_byte;          /*!< \brief This parameter is used by the transmitting side of each AM RLC entity to trigger a poll for every pollByte bytes. */
+  uint32_t           poll_byte;          /*!< \brief This parameter is used by the transmitting side of each AM RLC entity to trigger a poll for every pollByte bytes. */
 
   //---------------------------------------------------------------------
   // STATISTICS
@@ -176,14 +172,14 @@ typedef struct rlc_am_entity_s {
   //---------------------------------------------------------------------
   // OUTPUTS
   //---------------------------------------------------------------------
-  sdu_size_t        nb_bytes_requested_by_mac;  /*!< \brief Number of bytes requested by lower layer for next transmission. */
+  sdu_size_t        nb_bytes_requested_by_mac;  /*!< \brief Number of remaining bytes available for transmission of any RLC PDU indicated by lower layer */
   list_t            pdus_to_mac_layer;          /*!< \brief PDUs buffered for transmission to MAC layer. */
   list_t            control_pdu_list;           /*!< \brief Control PDUs buffered for transmission to MAC layer. */
-  rlc_sn_t          first_retrans_pdu_sn;       /*!< \brief Lowest sequence number of PDU to be retransmitted. */
   list_t            segmentation_pdu_list;      /*!< \brief List of "freshly" segmented PDUs. */
 
-  boolean_t         status_requested;             /*!< \brief Status requested by peer. */
-  frame_t           last_frame_status_indication; /*!< \brief The last frame number a  MAC status indication has been received by RLC. */
+  uint8_t           status_requested;             /*!< \brief Status bitmap requested by peer. */
+  rlc_sn_t		    sn_status_triggered_delayed;   /*!< \brief SN of the last received poll for which Status is delayed until SN is out of Rx Window. */
+  uint32_t          last_absolute_subframe_status_indication; /*!< \brief The last absolute subframe number a  MAC status indication has been received by RLC. */
   //-----------------------------
   // buffer occupancy measurements sent to MAC
   //-----------------------------

openair2/LAYER2/RLC/AM_v9.3.0/rlc_am_in_sdu.c

@@ -41,21 +41,28 @@ void rlc_am_free_in_sdu(
   const unsigned int            index_in_bufferP)
 {
   if (index_in_bufferP <= RLC_AM_SDU_CONTROL_BUFFER_SIZE) {
+	/* BugFix:  SDU shall have been already freed during initial PDU segmentation or concatenation !! */
+	  AssertFatal(rlcP->input_sdus[index_in_bufferP].mem_block == NULL, "RLC AM Tx SDU Conf: Data Part is not empty index=%d LcId=%d\n",
+				index_in_bufferP,rlcP->channel_id);
+	/*
     if (rlcP->input_sdus[index_in_bufferP].mem_block != NULL) {
       free_mem_block(rlcP->input_sdus[index_in_bufferP].mem_block, __func__);
       rlcP->input_sdus[index_in_bufferP].mem_block = NULL;
       rlcP->nb_sdu_no_segmented -= 1;
       rlcP->input_sdus[index_in_bufferP].sdu_remaining_size = 0;
     }
+    */
 
     rlcP->nb_sdu -= 1;
     memset(&rlcP->input_sdus[index_in_bufferP], 0, sizeof(rlc_am_tx_sdu_management_t));
     rlcP->input_sdus[index_in_bufferP].flags.transmitted_successfully = 1;
 
+    // case when either one SDU needs to be removed from segmentation or SDU buffer is full
     if (rlcP->current_sdu_index == index_in_bufferP) {
       rlcP->current_sdu_index = (rlcP->current_sdu_index + 1) % RLC_AM_SDU_CONTROL_BUFFER_SIZE;
     }
 
+    // wrapping and reset current_sdu_index to next_sdu_index when all transmitted SDUs have been acknowledged
     while ((rlcP->current_sdu_index != rlcP->next_sdu_index) &&
            (rlcP->input_sdus[rlcP->current_sdu_index].flags.transmitted_successfully == 1)) {
       rlcP->current_sdu_index = (rlcP->current_sdu_index + 1) % RLC_AM_SDU_CONTROL_BUFFER_SIZE;
@@ -100,3 +107,41 @@ rlc_am_in_sdu_is_empty(
 
   return 0;
 }
+
+// called when PDU is ACKED
+//-----------------------------------------------------------------------------
+void
+rlc_am_pdu_sdu_data_cnf(
+  const protocol_ctxt_t* const ctxt_pP,
+  rlc_am_entity_t* const       rlc_pP,
+  const rlc_sn_t           snP)
+{
+	  int          pdu_sdu_index;
+	  int          sdu_index;
+
+      for (pdu_sdu_index = 0; pdu_sdu_index < rlc_pP->tx_data_pdu_buffer[snP % RLC_AM_WINDOW_SIZE].nb_sdus; pdu_sdu_index++) {
+        sdu_index = rlc_pP->tx_data_pdu_buffer[snP % RLC_AM_WINDOW_SIZE].sdus_index[pdu_sdu_index];
+        assert(sdu_index >= 0);
+        assert(sdu_index < RLC_AM_SDU_CONTROL_BUFFER_SIZE);
+        rlc_pP->input_sdus[sdu_index].nb_pdus_ack += 1;
+
+        if ((rlc_pP->input_sdus[sdu_index].nb_pdus_ack == rlc_pP->input_sdus[sdu_index].nb_pdus) &&
+            (rlc_pP->input_sdus[sdu_index].sdu_remaining_size == 0)) {
+  #if TEST_RLC_AM
+          rlc_am_v9_3_0_test_data_conf (
+            rlc_pP->module_id,
+            rlc_pP->rb_id,
+            rlc_pP->input_sdus[sdu_index].mui,
+            RLC_SDU_CONFIRM_YES);
+  #else
+          rlc_data_conf(
+            ctxt_pP,
+            rlc_pP->rb_id,
+            rlc_pP->input_sdus[sdu_index].mui,
+            RLC_SDU_CONFIRM_YES,
+            rlc_pP->is_data_plane);
+  #endif
+          rlc_am_free_in_sdu(ctxt_pP, rlc_pP, sdu_index);
+        }
+      }
+}

openair2/LAYER2/RLC/AM_v9.3.0/rlc_am_in_sdu.h

@@ -77,5 +77,13 @@ protected_rlc_am_in_sdu(void rlc_am_free_in_sdu_data (const protocol_ctxt_t* con
 * \return 1 if the buffer is empty, else 0.
 */
 protected_rlc_am_in_sdu(signed int rlc_am_in_sdu_is_empty(const protocol_ctxt_t* const  ctxt_pP, rlc_am_entity_t *rlcP);)
+
+/*! \fn void rlc_am_pdu_sdu_data_cnf(const protocol_ctxt_t* const ctxt_pP,rlc_am_entity_t* const       rlc_pP,const rlc_sn_t           snP)
+* \brief    Process SDU cnf of a ACKED PDU for all SDUs concatenated in this PDU.
+* \param[in]  ctxtP                     Running context.
+* \param[in]  rlcP                      RLC AM protocol instance pointer.
+* \param[in]  snP                       Sequence number of the PDU.
+*/
+protected_rlc_am_in_sdu(void rlc_am_pdu_sdu_data_cnf(const protocol_ctxt_t* const ctxt_pP,rlc_am_entity_t* const       rlc_pP,const rlc_sn_t           snP);)
 /** @} */
 #    endif

openair2/LAYER2/RLC/AM_v9.3.0/rlc_am_init.c

@@ -51,16 +51,16 @@ rlc_am_init(
     pthread_mutex_init(&rlc_pP->lock_input_sdus, NULL);
     rlc_pP->input_sdus               = calloc(1, RLC_AM_SDU_CONTROL_BUFFER_SIZE*sizeof(rlc_am_tx_sdu_management_t));
 //#warning "cast the rlc retrans buffer to uint32"
-    //        rlc_pP->pdu_retrans_buffer       = calloc(1, (uint16_t)((unsigned int)RLC_AM_PDU_RETRANSMISSION_BUFFER_SIZE*(unsigned int)sizeof(rlc_am_tx_data_pdu_management_t)));
-    rlc_pP->pdu_retrans_buffer       = calloc(1, (uint32_t)((unsigned int)RLC_AM_PDU_RETRANSMISSION_BUFFER_SIZE*(unsigned int)sizeof(
+    //        rlc_pP->tx_data_pdu_buffer       = calloc(1, (uint16_t)((unsigned int)RLC_AM_PDU_RETRANSMISSION_BUFFER_SIZE*(unsigned int)sizeof(rlc_am_tx_data_pdu_management_t)));
+    rlc_pP->tx_data_pdu_buffer       = calloc(1, (uint32_t)((unsigned int)RLC_AM_PDU_RETRANSMISSION_BUFFER_SIZE*(unsigned int)sizeof(
                                          rlc_am_tx_data_pdu_management_t)));
     LOG_D(RLC, PROTOCOL_RLC_AM_CTXT_FMT"[AM INIT] input_sdus[] = %p  element size=%zu\n",
           PROTOCOL_RLC_AM_CTXT_ARGS(ctxt_pP,rlc_pP),
           rlc_pP->input_sdus,
           sizeof(rlc_am_tx_sdu_management_t));
-    LOG_D(RLC, PROTOCOL_RLC_AM_CTXT_FMT"[AM INIT] pdu_retrans_buffer[] = %p element size=%zu\n",
+    LOG_D(RLC, PROTOCOL_RLC_AM_CTXT_FMT"[AM INIT] tx_data_pdu_buffer[] = %p element size=%zu\n",
           PROTOCOL_RLC_AM_CTXT_ARGS(ctxt_pP,rlc_pP),
-          rlc_pP->pdu_retrans_buffer,
+          rlc_pP->tx_data_pdu_buffer,
           sizeof(rlc_am_tx_data_pdu_management_t));
 
     // TX state variables
@@ -74,12 +74,12 @@ rlc_am_init(
     // RX state variables
     //rlc_pP->vr_r    = 0;
     rlc_pP->vr_mr   = rlc_pP->vr_r + RLC_AM_WINDOW_SIZE;
-    //rlc_pP->vr_x    = 0;
+    rlc_pP->vr_x    = RLC_SN_UNDEFINED;
     //rlc_pP->vr_ms   = 0;
     //rlc_pP->vr_h    = 0;
+    rlc_pP->sn_status_triggered_delayed = RLC_SN_UNDEFINED;
 
-    rlc_pP->last_frame_status_indication = 123456; // any value > 1
-    rlc_pP->first_retrans_pdu_sn         = -1;
+    rlc_pP->last_absolute_subframe_status_indication = 0xFFFFFFFF; // any value > 1
 
     rlc_pP->initialized                  = TRUE;
   }
@@ -128,12 +128,13 @@ rlc_am_reestablish(
   // RX state variables
   rlc_pP->vr_r    = 0;
   rlc_pP->vr_mr   = rlc_pP->vr_r + RLC_AM_WINDOW_SIZE;
-  rlc_pP->vr_x    = 0;
+  rlc_pP->vr_x    = RLC_SN_UNDEFINED;
   rlc_pP->vr_ms   = 0;
   rlc_pP->vr_h    = 0;
+  rlc_pP->sn_status_triggered_delayed = RLC_SN_UNDEFINED;
+  rlc_pP->status_requested	= RLC_AM_STATUS_NOT_TRIGGERED;
 
-  rlc_pP->last_frame_status_indication = 123456; // any value > 1
-  rlc_pP->first_retrans_pdu_sn         = -1;
+  rlc_pP->last_absolute_subframe_status_indication = 0xFFFFFFFF; // any value > 1
 
   rlc_pP->initialized                  = TRUE;
 
@@ -172,16 +173,16 @@ rlc_am_cleanup(
 
   pthread_mutex_destroy(&rlc_pP->lock_input_sdus);
 
-  if (rlc_pP->pdu_retrans_buffer != NULL) {
+  if (rlc_pP->tx_data_pdu_buffer != NULL) {
     for (i=0; i < RLC_AM_PDU_RETRANSMISSION_BUFFER_SIZE; i++) {
-      if (rlc_pP->pdu_retrans_buffer[i].mem_block != NULL) {
-        free_mem_block(rlc_pP->pdu_retrans_buffer[i].mem_block, __func__);
-        rlc_pP->pdu_retrans_buffer[i].mem_block = NULL;
+      if (rlc_pP->tx_data_pdu_buffer[i % RLC_AM_WINDOW_SIZE].mem_block != NULL) {
+        free_mem_block(rlc_pP->tx_data_pdu_buffer[i % RLC_AM_WINDOW_SIZE].mem_block, __func__);
+        rlc_pP->tx_data_pdu_buffer[i % RLC_AM_WINDOW_SIZE].mem_block = NULL;
       }
     }
 
-    free(rlc_pP->pdu_retrans_buffer);
-    rlc_pP->pdu_retrans_buffer       = NULL;
+    free(rlc_pP->tx_data_pdu_buffer);
+    rlc_pP->tx_data_pdu_buffer       = NULL;
   }
 
   memset(rlc_pP, 0, sizeof(rlc_am_entity_t));

openair2/LAYER2/RLC/AM_v9.3.0/rlc_am_reassembly.c

@@ -212,7 +212,8 @@ void
 rlc_am_reassemble_pdu(
   const protocol_ctxt_t* const ctxt_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)
 {
   int i,j;
 
@@ -397,5 +398,7 @@ rlc_am_reassemble_pdu(
     }
   }
 
-  free_mem_block(tb_pP, __func__);
+  if (free_rlc_pdu) {
+	  free_mem_block(tb_pP, __func__);
+  }
 }

openair2/LAYER2/RLC/AM_v9.3.0/rlc_am_reassembly.h

@@ -72,13 +72,14 @@ private_rlc_am_reassembly(   void rlc_am_reassembly   (const protocol_ctxt_t* co
 */
 private_rlc_am_reassembly(   void rlc_am_send_sdu     (const protocol_ctxt_t* const ctxtP, rlc_am_entity_t * const rlc_pP);)
 
-/*! \fn void rlc_am_reassemble_pdu(const protocol_ctxt_t* const ctxtP, rlc_am_entity_t * const rlc_pP, const  mem_block_t* const tb_pP)
+/*! \fn void rlc_am_reassemble_pdu(const protocol_ctxt_t* const ctxtP, rlc_am_entity_t * const rlc_pP, const  mem_block_t* const tb_pP,boolean_t free_rlc_pdu)
 * \brief    Reassembly a RLC AM PDU, depending of the content of this PDU, data will be reassemblied to the current output SDU, the current will be sent to higher layers or not, after or before the reassembly, or no send of SDU will be triggered, depending on FI field in PDU header.
 * \param[in]  ctxtP                       Running context.
 * \param[in]  rlc_pP                      RLC AM protocol instance pointer.
 * \param[in]  tb_pP                       RLC AM PDU embedded in a mem_block_t.
+* \param[in]  free_rlc_pdu                Flag for freeing RLC AM PDU after reassembly.
 */
-protected_rlc_am_reassembly( void rlc_am_reassemble_pdu(const protocol_ctxt_t* const ctxtP, rlc_am_entity_t * const rlc_pP, mem_block_t* const tb_pP);)
+protected_rlc_am_reassembly( void rlc_am_reassemble_pdu(const protocol_ctxt_t* const ctxtP, rlc_am_entity_t * const rlc_pP, mem_block_t* const tb_pP,boolean_t free_rlc_pdu);)
 /** @} */
 #endif
 

openair2/LAYER2/RLC/AM_v9.3.0/rlc_am_retransmit.h

@@ -50,21 +50,24 @@
 #                define public_rlc_am_retransmit(x)     extern x
 #            endif
 #        endif
-/*! \fn void  rlc_am_nack_pdu (const protocol_ctxt_t* const  ctxt_pP, rlc_am_entity_t *rlcP, uint16_t snP, sdu_size_t so_startP, sdu_size_t so_endP)
+/*! \fn boolean_t  rlc_am_nack_pdu (const protocol_ctxt_t* const  ctxt_pP, rlc_am_entity_t *rlcP, int16_t snP, int16_t prev_nack_snP,sdu_size_t so_startP, sdu_size_t so_endP)
 * \brief      The RLC AM PDU which have the sequence number snP is marked NACKed with segment offset fields.
 * \param[in]  ctxtP        Running context.
 * \param[in]  rlcP         RLC AM protocol instance pointer.
 * \param[in]  snP          Sequence number of the PDU that is negative acknowledged.
+* \param[in]  prev_nack_snP  Sequence number of previous PDU that is negative acknowledged.
 * \param[in]  so_startP    Start of the segment offset of the PDU that .
 * \param[in]  so_endP      Transport blocks received from MAC layer.
+* \return                  OK/KO
 * \note It may appear a new hole in the retransmission buffer depending on the segment offset informations. Depending on the state of the retransmission buffer, negative confirmation can be sent to higher layers about the drop by the RLC AM instance of a particular SDU.
 */
-protected_rlc_am_retransmit(void         rlc_am_nack_pdu (
+protected_rlc_am_retransmit(boolean_t         rlc_am_nack_pdu (
                               const protocol_ctxt_t* const  ctxt_pP,
                               rlc_am_entity_t *const rlcP,
                               const rlc_sn_t snP,
-                              const sdu_size_t so_startP,
-                              const sdu_size_t so_endP);)
+							  const rlc_sn_t prev_nack_snP,
+                              sdu_size_t so_startP,
+                              sdu_size_t so_endP);)
 
 /*! \fn void rlc_am_ack_pdu (const protocol_ctxt_t* const  ctxt_pP,rlc_am_entity_t *rlcP, rlc_sn_t snP)
 * \brief      The RLC AM PDU which have the sequence number snP is marked ACKed.
@@ -90,6 +93,7 @@ protected_rlc_am_retransmit(mem_block_t* rlc_am_retransmit_get_copy (
                               rlc_am_entity_t *const rlcP,
                               const rlc_sn_t snP));
 
+#if 0
 /*! \fn mem_block_t* rlc_am_retransmit_get_subsegment (const protocol_ctxt_t* const  ctxt_pP,rlc_am_entity_t *rlcP,rlc_sn_t snP, sdu_size_t *sizeP)
 * \brief      The RLC AM PDU which have the sequence number snP is marked ACKed.
 * \param[in]  ctxtP        Running context.
@@ -103,7 +107,18 @@ protected_rlc_am_retransmit(mem_block_t* rlc_am_retransmit_get_subsegment (
                               rlc_am_entity_t *const rlcP,
                               const rlc_sn_t snP,
                               sdu_size_t *const sizeP));
+#endif
 
+/*! \fn mem_block_t* rlc_am_get_pdu_to_retransmit(const protocol_ctxt_t* const  ctxt_pP, rlc_am_entity_t* rlcP)
+* \brief      Find a PDU or PDU segment to retransmit.
+* \param[in]  ctxtP        Running context.
+* \param[in]  rlcP         RLC AM protocol instance pointer.
+* \return                  A copy of the retransmitted PDU or PDU segment or NULL if TBS was not big enough
+*/
+protected_rlc_am_retransmit(mem_block_t* rlc_am_get_pdu_to_retransmit(
+                              const protocol_ctxt_t* const  ctxt_pP,
+                              rlc_am_entity_t* const rlcP);)
+#if 0
 /*! \fn void rlc_am_retransmit_any_pdu(const protocol_ctxt_t* const  ctxt_pP, rlc_am_entity_t* rlcP)
 * \brief      Retransmit any PDU in order to unblock peer entity, if no suitable PDU is found (depending on requested MAC size) to be retransmitted, then try to retransmit a subsegment of any PDU.
 * \param[in]  ctxtP        Running context.
@@ -112,6 +127,7 @@ protected_rlc_am_retransmit(mem_block_t* rlc_am_retransmit_get_subsegment (
 protected_rlc_am_retransmit(void rlc_am_retransmit_any_pdu(
                               const protocol_ctxt_t* const  ctxt_pP,
                               rlc_am_entity_t* const rlcP);)
+#endif
 
 /*! \fn void rlc_am_tx_buffer_display (const protocol_ctxt_t* const  ctxt_pP,rlc_am_entity_t* rlcP,  char* message_pP)
 * \brief      Display the dump of the retransmission buffer.

openair2/LAYER2/RLC/AM_v9.3.0/rlc_am_rx_list.h

@@ -59,6 +59,16 @@
 #include "PHY/defs.h"
 
 //-----------------------------------------------------------------------------
+/*! \fn rlc_am_rx_pdu_status_t rlc_am_rx_list_check_duplicate_insert_pdu(const protocol_ctxt_t* const  ctxt_pP,rlc_am_entity_t* const rlc_pP,mem_block_t* const tb_pP)
+* \brief      Insert a PDU in the RX buffer after removing byte duplicate (implemented with a list).
+* \param[in]  ctxt_pP        Running context.
+* \param[in]  rlcP         RLC AM protocol instance pointer.
+* \param[in]  tbP          A PDU embedded in a mem_block_t.
+* \return     Zero if the PDU could be inserted in the RX buffer, a negative value if the PDU could not be inserted.
+*/
+protected_rlc_am_rx_list( rlc_am_rx_pdu_status_t rlc_am_rx_list_check_duplicate_insert_pdu(const protocol_ctxt_t* const  ctxt_pP,rlc_am_entity_t* const rlc_pP,mem_block_t* const tb_pP);)
+
+#if 0
 /*! \fn signed int rlc_am_rx_list_insert_pdu(const protocol_ctxt_t* const ctxt_pP, rlc_am_entity_t* const rlcP , mem_block_t* const tbP)
 * \brief      Insert a PDU in the RX buffer (implemented with a list).
 * \param[in]  ctxt_pP        Running context.
@@ -67,6 +77,15 @@
 * \return     Zero if the PDU could be inserted in the RX buffer, a negative value if the PDU could not be inserted.
 */
 protected_rlc_am_rx_list( signed int rlc_am_rx_list_insert_pdu(const protocol_ctxt_t* const ctxt_pP, rlc_am_entity_t* const rlcP,  mem_block_t* const tbP);)
+#endif
+
+/*! \fn boolean_t rlc_am_rx_check_vr_reassemble(const protocol_ctxt_t* const ctxt_pP,const rlc_am_entity_t* const rlc_pP)
+* \brief      Check if reassembly taking into account potential new vrR value
+* \param[in]  ctxt_pP        Running context.
+* \param[in]  rlcP         RLC AM protocol instance pointer.
+* \return     TRUE if reassembly must be done, FALSE else
+*/
+protected_rlc_am_rx_list( boolean_t rlc_am_rx_check_vr_reassemble(const protocol_ctxt_t* const ctxt_pP,const rlc_am_entity_t* const rlc_pP);)
 
 /*! \fn void rlc_am_rx_check_all_byte_segments(const protocol_ctxt_t* const ctxt_pP, rlc_am_entity_t* const rlcP, mem_block_t* const tbP)
 * \brief      Check if all sub-segments of a PDU are received, if yes then call rlc_am_rx_mark_all_segments_received() procedure.

openair2/LAYER2/RLC/AM_v9.3.0/rlc_am_segment.c

@@ -39,7 +39,8 @@ void rlc_am_pdu_polling (
   const protocol_ctxt_t* const  ctxt_pP,
   rlc_am_entity_t *const rlc_pP,
   rlc_am_pdu_sn_10_t *const pdu_pP,
-  const int16_t payload_sizeP)
+  const int16_t payload_sizeP,
+  boolean_t is_new_pdu)
 {
   // 5.2.2 Polling
   // An AM RLC entity can poll its peer AM RLC entity in order to trigger STATUS reporting at the peer AM RLC entity.
@@ -68,49 +69,59 @@ void rlc_am_pdu_polling (
   //         - start t-PollRetransmit;
   //     - else:
   //         - restart t-PollRetransmit;
-  rlc_pP->c_pdu_without_poll     += 1;
-  rlc_pP->c_byte_without_poll    += payload_sizeP;
+
+  if (is_new_pdu) {
+	  if (rlc_pP->poll_pdu != RLC_AM_POLL_PDU_INFINITE) {
+		  rlc_pP->c_pdu_without_poll     += 1;
+	  }
+
+	  if (rlc_pP->poll_byte != RLC_AM_POLL_BYTE_INFINITE) {
+		  rlc_pP->c_byte_without_poll    += payload_sizeP;
+	  }
+  }
 
   if (
-    (rlc_pP->c_pdu_without_poll >= rlc_pP->poll_pdu) ||
-    (rlc_pP->c_byte_without_poll >= rlc_pP->poll_byte) ||
+    ((is_new_pdu) && ((rlc_pP->c_pdu_without_poll >= rlc_pP->poll_pdu) ||
+    (rlc_pP->c_byte_without_poll >= rlc_pP->poll_byte))) ||
     ((rlc_pP->sdu_buffer_occupancy == 0) && (rlc_pP->retrans_num_bytes_to_retransmit == 0)) ||
     (rlc_pP->vt_s == rlc_pP->vt_ms) ||
-    (rlc_pP->force_poll == TRUE)
+    (rlc_pP->force_poll == true)
   ) {
-	rlc_pP->force_poll = FALSE;
+	rlc_pP->force_poll = false;
 
-    if (rlc_pP->c_pdu_without_poll >= rlc_pP->poll_pdu) {
+    if ((is_new_pdu) && (rlc_pP->c_pdu_without_poll >= rlc_pP->poll_pdu)) {
       LOG_T(RLC, PROTOCOL_RLC_AM_CTXT_FMT"[POLL] SET POLL BECAUSE TX NUM PDU THRESHOLD %d  HAS BEEN REACHED\n",
             PROTOCOL_RLC_AM_CTXT_ARGS(ctxt_pP,rlc_pP),
             rlc_pP->poll_pdu);
-    } else
-    if (rlc_pP->c_byte_without_poll >= rlc_pP->poll_byte) {
+    }
+    if ((is_new_pdu) && (rlc_pP->c_byte_without_poll >= rlc_pP->poll_byte)) {
       LOG_T(RLC, PROTOCOL_RLC_AM_CTXT_FMT"[POLL] SET POLL BECAUSE TX NUM BYTES THRESHOLD %d  HAS BEEN REACHED\n",
             PROTOCOL_RLC_AM_CTXT_ARGS(ctxt_pP,rlc_pP),
             rlc_pP->poll_byte);
-    } else
+    }
     if ((rlc_pP->sdu_buffer_occupancy == 0) && (rlc_pP->retrans_num_bytes_to_retransmit == 0)) {
       LOG_T(RLC, PROTOCOL_RLC_AM_CTXT_FMT"[POLL] SET POLL BECAUSE TX BUFFERS ARE EMPTY\n",
             PROTOCOL_RLC_AM_CTXT_ARGS(ctxt_pP,rlc_pP));
-    } else
+    }
     if (rlc_pP->vt_s == rlc_pP->vt_ms) {
       LOG_T(RLC, PROTOCOL_RLC_AM_CTXT_FMT"[POLL] SET POLL BECAUSE OF WINDOW STALLING\n",
             PROTOCOL_RLC_AM_CTXT_ARGS(ctxt_pP,rlc_pP));
     }
 
-    pdu_pP->b1 = pdu_pP->b1 | 0x20;
+    RLC_AM_PDU_SET_POLL(pdu_pP->b1);
     rlc_pP->c_pdu_without_poll     = 0;
     rlc_pP->c_byte_without_poll    = 0;
 
-    rlc_pP->poll_sn = (rlc_pP->vt_s -1) & RLC_AM_SN_MASK;
+    // vt_s shall have been updated before in case of new transmission
+    rlc_pP->poll_sn = RLC_AM_PREV_SN(rlc_pP->vt_s);
     //optimisation if (!rlc_pP->t_poll_retransmit.running) {
     rlc_am_start_timer_poll_retransmit(ctxt_pP, rlc_pP);
     //optimisation } else {
     //optimisation     rlc_pP->t_poll_retransmit.frame_time_out = ctxt_pP->frame + rlc_pP->t_poll_retransmit.time_out;
     //optimisation }
   } else {
-    pdu_pP->b1 = pdu_pP->b1 & 0xDF;
+	  // Need to clear poll bit as it may be a copy(retransmission case) of the original RLC PDU which was containing a poll
+	RLC_AM_PDU_CLEAR_POLL(pdu_pP->b1);
   }
 }
 //-----------------------------------------------------------------------------
@@ -178,7 +189,9 @@ void rlc_am_segment_10 (
       if (rlc_pP->nb_sdu_no_segmented <= 1) {
         max_li_overhead = 0;
       } else {
-        max_li_overhead = (((rlc_pP->nb_sdu_no_segmented - 1) * 3) / 2) + ((rlc_pP->nb_sdu_no_segmented - 1) % 2);
+    	/* This computation assumes there is no SDU with size greater than 2047 bytes, otherwise a new PDU must be built except for LI15 configuration from Rel12*/
+    	test_num_li = rlc_pP->nb_sdu_no_segmented - 1;
+        max_li_overhead = test_num_li + (test_num_li >> 1) + (test_num_li & 1);
       }
 
       LOG_T(RLC, PROTOCOL_RLC_AM_CTXT_FMT"[SEGMENT] max_li_overhead %d\n",
@@ -210,7 +223,7 @@ void rlc_am_segment_10 (
       pdu_remaining_size = data_pdu_size - RLC_AM_HEADER_MIN_SIZE;
       pdu_p        = (rlc_am_pdu_sn_10_t*) (&pdu_mem_p->data[sizeof(struct mac_tb_req)]);
       pdu_tb_req_p = (struct mac_tb_req*) (pdu_mem_p->data);
-      pdu_mngt_p   = &rlc_pP->pdu_retrans_buffer[rlc_pP->vt_s % RLC_AM_PDU_RETRANSMISSION_BUFFER_SIZE];
+      pdu_mngt_p   = &rlc_pP->tx_data_pdu_buffer[rlc_pP->vt_s % RLC_AM_PDU_RETRANSMISSION_BUFFER_SIZE];
       memset(pdu_mngt_p, 0, sizeof (rlc_am_tx_data_pdu_management_t));
 
       memset (pdu_mem_p->data, 0, sizeof (rlc_am_pdu_sn_10_t)+sizeof(struct mac_tb_req));
@@ -485,11 +498,11 @@ void rlc_am_segment_10 (
       fi = fi + 1;
     }
 
-    pdu_p->b1 = pdu_p->b1 | (fi << 3);
+    pdu_p->b1 = pdu_p->b1 | (fi << RLC_AM_PDU_FI_OFFSET);
 
     // set fist e bit
     if (fill_num_li > 0) {
-      pdu_p->b1 = pdu_p->b1 | 0x04;
+    	RLC_AM_PDU_SET_E(pdu_p->b1);
     }
 
     LOG_T(RLC, PROTOCOL_RLC_AM_CTXT_FMT"[SEGMENT] SEND PDU SN %04d  SIZE %d BYTES PAYLOAD SIZE %d BYTES\n",
@@ -501,8 +514,9 @@ void rlc_am_segment_10 (
     rlc_pP->stat_tx_data_pdu   += 1;
     rlc_pP->stat_tx_data_bytes += (data_pdu_size - pdu_remaining_size);
 
-    //pdu_p->sn = rlc_pP->vt_s;
-    pdu_p->b1 = pdu_p->b1 | 0x80; // DATA/CONTROL field is DATA PDU
+    // set DATA/CONTROL field is DATA PDU(1)
+    RLC_AM_PDU_SET_D_C(pdu_p->b1);
+    // set sn = rlc_pP->vt_s;
     pdu_p->b1 = pdu_p->b1 | (rlc_pP->vt_s >> 8);
     pdu_p->b2 = rlc_pP->vt_s & 0xFF;
     rlc_pP->vt_s = (rlc_pP->vt_s+1) & RLC_AM_SN_MASK;
@@ -511,24 +525,28 @@ void rlc_am_segment_10 (
     pdu_tb_req_p->tb_size         = data_pdu_size - pdu_remaining_size;
 //#warning "why 3000: changed to RLC_SDU_MAX_SIZE "
     assert(pdu_tb_req_p->tb_size < RLC_SDU_MAX_SIZE );
-    rlc_am_pdu_polling(ctxt_pP, rlc_pP, pdu_p, pdu_mngt_p->payload_size);
+    rlc_am_pdu_polling(ctxt_pP, rlc_pP, pdu_p, pdu_mngt_p->payload_size,true);
 
     //list_add_tail_eurecom (pdu_mem_p, &rlc_pP->segmentation_pdu_list);
     pdu_mngt_p->mem_block  = pdu_mem_p;
     pdu_mngt_p->first_byte = (unsigned char*)pdu_p;
     pdu_mngt_p->header_and_payload_size  = data_pdu_size - pdu_remaining_size;
-    pdu_mngt_p->retx_count = -1;
+    pdu_mngt_p->retx_count = 0;
+    pdu_mngt_p->retx_count_next = 0;
+    pdu_mngt_p->flags.retransmit = 0;
+    pdu_mngt_p->flags.transmitted = 1;
+    pdu_mngt_p->sn = RLC_AM_PREV_SN(rlc_pP->vt_s);
 
-    rlc_pP->retrans_num_pdus  += 1;
-    rlc_pP->retrans_num_bytes += pdu_mngt_p->header_and_payload_size;
 
+    //TBC: What for resetting local pointers at the end ??
     pdu_p = NULL;
     pdu_mem_p = NULL;
 
     //nb_bytes_to_transmit = nb_bytes_to_transmit - data_pdu_size;
     nb_bytes_to_transmit = 0; // 1 PDU only
 
-    mem_block_t* copy = rlc_am_retransmit_get_copy (ctxt_pP, rlc_pP, (rlc_pP->vt_s-1) & RLC_AM_SN_MASK);
+    /* We need to copy the PDU to pass to MAC in order to keep it in the buffer for potential retransmissions */
+    mem_block_t* copy = rlc_am_retransmit_get_copy (ctxt_pP, rlc_pP, RLC_AM_PREV_SN(rlc_pP->vt_s));
     list_add_tail_eurecom (copy, &rlc_pP->segmentation_pdu_list);
 
   }

openair2/LAYER2/RLC/AM_v9.3.0/rlc_am_segment.h

@@ -51,14 +51,14 @@
 #            endif
 #        endif
 
-/*! \fn void rlc_am_pdu_polling (const protocol_ctxt_t* const  ctxt_pP, rlc_am_entity_t *const rlcP, rlc_am_pdu_sn_10_t *pduP, int16_t payload_sizeP)
+/*! \fn void rlc_am_pdu_polling (const protocol_ctxt_t* const  ctxt_pP, rlc_am_entity_t *const rlcP, rlc_am_pdu_sn_10_t *pduP, int16_t payload_sizeP,boolean_t is_new_pdu)
 * \brief      Set or not the poll bit in the PDU header depending on RLC AM protocol variables.
 * \param[in]  ctxt_pP          Running context.
 * \param[in]  rlcP           RLC AM protocol instance pointer.
 * \param[in]  pduP           Pointer on the header of the PDU in order to be able to set the poll bit if necessary.
 * \param[in]  payload_sizeP  Size of the payload of the PDU.
 */
-protected_rlc_am_segment(void rlc_am_pdu_polling (const protocol_ctxt_t* const  ctxt_pP, rlc_am_entity_t *const rlcP, rlc_am_pdu_sn_10_t *pduP, int16_t payload_sizeP);)
+protected_rlc_am_segment(void rlc_am_pdu_polling (const protocol_ctxt_t* const  ctxt_pP, rlc_am_entity_t *const rlcP, rlc_am_pdu_sn_10_t *pduP, int16_t payload_sizeP,boolean_t is_new_pdu);)
 
 /*! \fn void rlc_am_segment_10 (const protocol_ctxt_t* const  ctxt_pP, rlc_am_entity_t * const rlcP)
 * \brief      Segment a PDU with 10 bits sequence number, based on segmentation information given by MAC (size to transmit).

openair2/LAYER2/RLC/AM_v9.3.0/rlc_am_segments_holes.h

@@ -32,7 +32,7 @@
 * @ingroup _rlc_am_internal_segment_impl_
 * @{
 */
-
+#if 0
 #ifndef __RLC_AM_SEGMENT_HOLES_H__
 #    define __RLC_AM_SEGMENT_HOLES_H__
 //-----------------------------------------------------------------------------
@@ -108,3 +108,4 @@ protected_rlc_am_segments_holes(void rlc_am_add_hole (
                                   sdu_size_t so_stopP);)
 /** @} */
 #endif
+#endif

openair2/LAYER2/RLC/AM_v9.3.0/rlc_am_timer_status_prohibit.c

@@ -70,6 +70,8 @@ rlc_am_check_timer_status_prohibit(
               PROTOCOL_RLC_AM_CTXT_ARGS(ctxt_pP,rlc_pP));
         //#warning         TO DO rlc_am_check_timer_status_prohibit
         rlc_am_stop_and_reset_timer_status_prohibit(ctxt_pP, rlc_pP);
+        /* Clear StatusProhibit flag */
+        RLC_AM_CLEAR_STATUS(rlc_pP->status_requested,RLC_AM_STATUS_PROHIBIT);
         //rlc_pP->t_status_prohibit.frame_time_out = ctxt_pP->frame + rlc_pP->t_status_prohibit.time_out;
       }
     }
@@ -110,6 +112,7 @@ rlc_am_start_timer_status_prohibit(
       rlc_pP->t_status_prohibit.running        = 1;
       rlc_pP->t_status_prohibit.ms_time_out    = rlc_pP->t_status_prohibit.ms_duration + PROTOCOL_CTXT_TIME_MILLI_SECONDS(ctxt_pP);
       rlc_pP->t_status_prohibit.ms_start       = PROTOCOL_CTXT_TIME_MILLI_SECONDS(ctxt_pP);
+      RLC_AM_SET_STATUS(rlc_pP->status_requested,RLC_AM_STATUS_PROHIBIT);
       LOG_D(RLC, PROTOCOL_RLC_AM_CTXT_FMT"[T-STATUS-PROHIBIT] STARTED (TIME-OUT = %u ms)\n",
           PROTOCOL_RLC_AM_CTXT_ARGS(ctxt_pP,rlc_pP),
           rlc_pP->t_status_prohibit.ms_time_out);