attempt at synchronous PDCP RRC communication in the nr UE

When the UE receives several PDCP packets in one MAC PDU, if the
first is SecurityModeCommand, the following will be ciphered/integrity
protected. The RRC has to process SecurityModeCommand before PDCP
processes the following packets. Before this commit, PDCP will
not wait for RRC to finish and process the following messages, which
won't make any sense since they are ciphered but ciphering is not
configured yet.

So let's introduce some synchronous commmunication between PDCP
and RRC for SRBs in the UE. PDCP sends the data to RRC and waits
for a return message from RRC to continue its job.

The code is not super satisfying. nr_pdcp_entity_recv_pdu() may queue
the message and not send it to RRC immediately, so do_pdcp_data_ind()
may wait for a long time and maybe forever, I did  not analyze things
properly here. (The queuing is easy to detect, we could AssertFatal()
if that happens. Then find a proper solution if the case happens for
real and turns out being super annoying.)

Just an attempt, let's see.

openair2/COMMON/pdcp_messages_def.h

@@ -37,3 +37,4 @@ MESSAGE_DEF(RRC_DCCH_DATA_COPY_IND,     MESSAGE_PRIORITY_MED_PLUS, RrcDcchDataIn
 // gNB
 MESSAGE_DEF(NR_RRC_DCCH_DATA_REQ,       MESSAGE_PRIORITY_MED_PLUS, NRRrcDcchDataReq,           nr_rrc_dcch_data_req)
 MESSAGE_DEF(NR_RRC_DCCH_DATA_IND,       MESSAGE_PRIORITY_MED_PLUS, NRRrcDcchDataInd,           nr_rrc_dcch_data_ind)
+MESSAGE_DEF(NR_RRC_DCCH_DATA_RESP,      MESSAGE_PRIORITY_MED_PLUS, RrcDcchDataResp,            nr_rrc_dcch_data_resp)

openair2/COMMON/pdcp_messages_types.h

@@ -67,6 +67,10 @@ typedef struct RrcDcchDataInd_s {
   uint8_t      eNB_index; // LG: needed in UE
 } RrcDcchDataInd;
 
+typedef struct RrcDcchDataResp_s {
+  /* nothing */
+} RrcDcchDataResp;
+
 typedef struct RrcDcchDataCopyInd_s {
   uint8_t dcch_index;
   uint32_t sdu_size;

openair2/LAYER2/nr_pdcp/nr_pdcp_entity.c

@@ -42,8 +42,8 @@ int nr_max_pdcp_pdu_size(sdu_size_t sdu_size)
   return (sdu_size + LONG_PDCP_HEADER_SIZE + PDCP_INTEGRITY_SIZE);
 }
 
-static void nr_pdcp_entity_recv_pdu(nr_pdcp_entity_t *entity,
-                                    char *_buffer, int size)
+static int nr_pdcp_entity_recv_pdu(nr_pdcp_entity_t *entity,
+                                   char *_buffer, int size)
 {
   unsigned char    *buffer = (unsigned char *)_buffer;
   nr_pdcp_sdu_t    *sdu;
@@ -58,12 +58,12 @@ static void nr_pdcp_entity_recv_pdu(nr_pdcp_entity_t *entity,
 
   if (entity->entity_suspended) {
     LOG_W(PDCP, "PDCP entity %d is suspended. Quit RX procedure.\n", entity->rb_id);
-    return;
+    return -1;
   }
 
   if (size < 1) {
     LOG_E(PDCP, "bad PDU received (size = %d)\n", size);
-    return;
+    return -1;
   }
 
   if (entity->type != NR_PDCP_SRB && !(buffer[0] & 0x80)) {
@@ -105,7 +105,7 @@ static void nr_pdcp_entity_recv_pdu(nr_pdcp_entity_t *entity,
     entity->stats.rxpdu_dd_pkts++;
     entity->stats.rxpdu_dd_bytes += size;
 
-    return;
+    return -1;
   }
 
   rx_deliv_sn  = entity->rx_deliv & entity->sn_max;
@@ -147,7 +147,7 @@ static void nr_pdcp_entity_recv_pdu(nr_pdcp_entity_t *entity,
       entity->stats.rxpdu_dd_pkts++;
       entity->stats.rxpdu_dd_bytes += size;
 
-      return;
+      return -1;
     }
   }
 
@@ -157,7 +157,7 @@ static void nr_pdcp_entity_recv_pdu(nr_pdcp_entity_t *entity,
     entity->stats.rxpdu_dd_pkts++;
     entity->stats.rxpdu_dd_bytes += size;
 
-    return;
+    return -1;
   }
 
   sdu = nr_pdcp_new_sdu(rcvd_count,
@@ -201,6 +201,8 @@ static void nr_pdcp_entity_recv_pdu(nr_pdcp_entity_t *entity,
     entity->rx_reord = entity->rx_next;
     entity->t_reordering_start = entity->t_current;
   }
+
+  return 0;
 }
 
 static int nr_pdcp_entity_process_sdu(nr_pdcp_entity_t *entity,

openair2/LAYER2/nr_pdcp/nr_pdcp_entity.h

@@ -84,7 +84,7 @@ typedef struct nr_pdcp_entity_t {
   nr_pdcp_entity_type_t type;
 
   /* functions provided by the PDCP module */
-  void (*recv_pdu)(struct nr_pdcp_entity_t *entity, char *buffer, int size);
+  int (*recv_pdu)(struct nr_pdcp_entity_t *entity, char *buffer, int size);
   int (*process_sdu)(struct nr_pdcp_entity_t *entity, char *buffer, int size,
                      int sdu_id, char *pdu_buffer, int pdu_max_size);
   void (*delete_entity)(struct nr_pdcp_entity_t *entity);

openair2/LAYER2/nr_pdcp/nr_pdcp_oai_api.c

@@ -284,8 +284,10 @@ static void do_pdcp_data_ind(const protocol_ctxt_t *const ctxt_pP,
   ue = nr_pdcp_manager_get_ue(nr_pdcp_ue_manager, UEid);
   rb = nr_pdcp_get_rb(ue, rb_id, srb_flagP);
 
+  int ret = -1;
+
   if (rb != NULL) {
-    rb->recv_pdu(rb, (char *)sdu_buffer, sdu_buffer_size);
+    ret = rb->recv_pdu(rb, (char *)sdu_buffer, sdu_buffer_size);
   } else {
     LOG_E(PDCP, "pdcp_data_ind: no RB found (rb_id %ld, srb_flag %d)\n", rb_id, srb_flagP);
   }
@@ -293,6 +295,14 @@ static void do_pdcp_data_ind(const protocol_ctxt_t *const ctxt_pP,
   nr_pdcp_manager_unlock(nr_pdcp_ue_manager);
 
   free(sdu_buffer);
+
+  /* UE: wait for RRC to indicate the processing of the message */
+  if (ctxt_pP->enb_flag == 0 && srb_flagP && ret == 0) {
+    MessageDef *Resp;
+    itti_receive_msg(TASK_PDCP_UE, &Resp);
+    AssertFatal(ITTI_MSG_ID(Resp) == NR_RRC_DCCH_DATA_RESP, "bad response from NR RRC\n");
+    itti_free(ITTI_MSG_ORIGIN_ID(Resp), Resp);
+  }
 }
 
 static void *pdcp_data_ind_thread(void *_)

openair2/RRC/NR_UE/rrc_UE.c

@@ -1782,6 +1782,8 @@ void *rrc_nrue(void *notUsed)
 			  NR_RRC_DCCH_DATA_IND(msg_p).sdu_size,
 			  NR_RRC_DCCH_DATA_IND(msg_p).gNB_index,
 			  &NR_RRC_DCCH_DATA_IND(msg_p).msg_integrity);
+    MessageDef *msg = itti_alloc_new_message(TASK_PDCP_UE, 0, NR_RRC_DCCH_DATA_RESP);
+    itti_send_msg_to_task(TASK_PDCP_UE, rrc->ue_id, msg);
     break;
 
   case NAS_KENB_REFRESH_REQ: