Use F1 UE context Release Request in stack

Switch to the new type, remove the old one.

openair2/COMMON/f1ap_messages_def.h

@@ -48,7 +48,7 @@ MESSAGE_DEF(F1AP_INITIAL_UL_RRC_MESSAGE           , MESSAGE_PRIORITY_MED, f1ap_i
 MESSAGE_DEF(F1AP_UL_RRC_MESSAGE                , MESSAGE_PRIORITY_MED, f1ap_ul_rrc_message_t                , f1ap_ul_rrc_message)
 //MESSAGE_DEF(F1AP_INITIAL_CONTEXT_SETUP_RESP, MESSAGE_PRIORITY_MED, f1ap_initial_context_setup_resp_t, f1ap_initial_context_setup_resp)
 //MESSAGE_DEF(F1AP_INITIAL_CONTEXT_SETUP_FAILURE, MESSAGE_PRIORITY_MED, f1ap_initial_context_setup_failure_t, f1ap_initial_context_setup_failure)
-MESSAGE_DEF(F1AP_UE_CONTEXT_RELEASE_REQ, MESSAGE_PRIORITY_MED, f1ap_ue_context_release_req_t, f1ap_ue_context_release_req)
+MESSAGE_DEF(F1AP_UE_CONTEXT_RELEASE_REQ, MESSAGE_PRIORITY_MED, f1ap_ue_context_rel_req_t, f1ap_ue_context_release_req)
 MESSAGE_DEF(F1AP_UE_CONTEXT_RELEASE_CMD, MESSAGE_PRIORITY_MED, f1ap_ue_context_release_cmd_t, f1ap_ue_context_release_cmd)
 MESSAGE_DEF(F1AP_UE_CONTEXT_RELEASE_COMPLETE, MESSAGE_PRIORITY_MED, f1ap_ue_context_release_complete_t, f1ap_ue_context_release_complete)
 MESSAGE_DEF(F1AP_UE_CONTEXT_MODIFICATION_REQUIRED, MESSAGE_PRIORITY_MED, f1ap_ue_context_modif_required_t, f1ap_ue_context_modification_required)

openair2/COMMON/f1ap_messages_types.h

@@ -664,7 +664,7 @@ typedef struct f1ap_ue_context_release_s {
   uint8_t      *rrc_container;
   int           rrc_container_length;
   int           srb_id;
-} f1ap_ue_context_release_req_t, f1ap_ue_context_release_cmd_t, f1ap_ue_context_release_complete_t;
+} f1ap_ue_context_release_cmd_t, f1ap_ue_context_release_complete_t;
 
 typedef struct f1ap_paging_ind_s {
   uint16_t ueidentityindexvalue;

openair2/F1AP/f1ap_cu_ue_context_management.c

@@ -90,58 +90,17 @@ int CU_handle_UE_CONTEXT_SETUP_FAILURE(instance_t instance, sctp_assoc_t assoc_i
 
 int CU_handle_UE_CONTEXT_RELEASE_REQUEST(instance_t instance, sctp_assoc_t assoc_id, uint32_t stream, F1AP_F1AP_PDU_t *pdu)
 {
+  f1ap_ue_context_rel_req_t req = {0};
+  if (!decode_ue_context_rel_req(pdu, &req)) {
+    LOG_E(F1AP, "cannot decode F1 UE Context Release Request\n");
+    free_ue_context_rel_req(&req);
+    return -1;
+  }
+
   MessageDef *msg = itti_alloc_new_message(TASK_CU_F1, 0,  F1AP_UE_CONTEXT_RELEASE_REQ);
   msg->ittiMsgHeader.originInstance = assoc_id;
-  f1ap_ue_context_release_req_t *req = &F1AP_UE_CONTEXT_RELEASE_REQ(msg);
+  F1AP_UE_CONTEXT_RELEASE_REQ(msg) = req;
-  F1AP_UEContextReleaseRequest_t    *container;
-  F1AP_UEContextReleaseRequestIEs_t *ie;
-  DevAssert(pdu);
-  container = &pdu->choice.initiatingMessage->value.choice.UEContextReleaseRequest;
-  /* GNB_CU_UE_F1AP_ID */
-  F1AP_FIND_PROTOCOLIE_BY_ID(F1AP_UEContextReleaseRequestIEs_t, ie, container,
-                             F1AP_ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID, true);
-  req->gNB_CU_ue_id = ie->value.choice.GNB_CU_UE_F1AP_ID;
-
-  /* GNB_DU_UE_F1AP_ID */
-  F1AP_FIND_PROTOCOLIE_BY_ID(F1AP_UEContextReleaseRequestIEs_t, ie, container,
-                             F1AP_ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID, true);
-  req->gNB_DU_ue_id = ie->value.choice.GNB_DU_UE_F1AP_ID;
-
-  /* Cause */
-  F1AP_FIND_PROTOCOLIE_BY_ID(F1AP_UEContextReleaseRequestIEs_t, ie, container,
-                             F1AP_ProtocolIE_ID_id_Cause, true);
-
-  switch(ie->value.choice.Cause.present)
-  {
-    case F1AP_Cause_PR_radioNetwork:
-      req->cause = F1AP_CAUSE_RADIO_NETWORK;
-      req->cause_value = ie->value.choice.Cause.choice.radioNetwork;
-      break;
-    case F1AP_Cause_PR_transport:
-      req->cause = F1AP_CAUSE_TRANSPORT;
-      req->cause_value = ie->value.choice.Cause.choice.transport;
-      break;
-    case F1AP_Cause_PR_protocol:
-      req->cause = F1AP_CAUSE_PROTOCOL;
-      req->cause_value = ie->value.choice.Cause.choice.protocol;
-      break;
-    case F1AP_Cause_PR_misc:
-      req->cause = F1AP_CAUSE_MISC;
-      req->cause_value = ie->value.choice.Cause.choice.misc;
-      break;
-    case F1AP_Cause_PR_NOTHING:
-    default:
-      req->cause = F1AP_CAUSE_NOTHING;
-      break;
-  }
-
-  F1AP_FIND_PROTOCOLIE_BY_ID(F1AP_UEContextReleaseRequestIEs_t, ie, container, F1AP_ProtocolIE_ID_id_targetCellsToCancel, false);
-  if (ie != NULL) {
-    LOG_W(F1AP, "ignoring list of target cells to cancel in UE Context Release Request: implementation missing\n");
-  }
-
   itti_send_msg_to_task(TASK_RRC_GNB, instance, msg);
-
   return 0;
 }
 

openair2/F1AP/f1ap_du_ue_context_management.c

@@ -76,75 +76,19 @@ int DU_send_UE_CONTEXT_SETUP_FAILURE(sctp_assoc_t assoc_id)
   AssertFatal(1==0,"Not implemented yet\n");
 }
 
-int DU_send_UE_CONTEXT_RELEASE_REQUEST(sctp_assoc_t assoc_id, f1ap_ue_context_release_req_t *req)
+int DU_send_UE_CONTEXT_RELEASE_REQUEST(sctp_assoc_t assoc_id, f1ap_ue_context_rel_req_t *req)
 {
-  F1AP_F1AP_PDU_t                   pdu = {0};
+  F1AP_F1AP_PDU_t *pdu = encode_ue_context_rel_req(req);
-  F1AP_UEContextReleaseRequest_t    *out;
-  uint8_t  *buffer=NULL;
-  uint32_t  len=0;
-  /* Create */
-  /* 0. Message Type */
-  pdu.present = F1AP_F1AP_PDU_PR_initiatingMessage;
-  asn1cCalloc(pdu.choice.initiatingMessage, tmp);
-  tmp->procedureCode = F1AP_ProcedureCode_id_UEContextReleaseRequest;
-  tmp->criticality   = F1AP_Criticality_reject;
-  tmp->value.present = F1AP_InitiatingMessage__value_PR_UEContextReleaseRequest;
-  out = &tmp->value.choice.UEContextReleaseRequest;
-  /* mandatory */
-  /* c1. GNB_CU_UE_F1AP_ID */
-  asn1cSequenceAdd(out->protocolIEs.list, F1AP_UEContextReleaseRequestIEs_t, ie1);
-  ie1->id                             = F1AP_ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID;
-  ie1->criticality                    = F1AP_Criticality_reject;
-  ie1->value.present                  = F1AP_UEContextReleaseRequestIEs__value_PR_GNB_CU_UE_F1AP_ID;
-  ie1->value.choice.GNB_CU_UE_F1AP_ID = req->gNB_CU_ue_id;
-  /* mandatory */
-  /* c2. GNB_DU_UE_F1AP_ID */
-  asn1cSequenceAdd(out->protocolIEs.list, F1AP_UEContextReleaseRequestIEs_t, ie2);
-  ie2->id                             = F1AP_ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
-  ie2->criticality                    = F1AP_Criticality_reject;
-  ie2->value.present                  = F1AP_UEContextReleaseRequestIEs__value_PR_GNB_DU_UE_F1AP_ID;
-  ie2->value.choice.GNB_DU_UE_F1AP_ID = req->gNB_DU_ue_id;
-  /* mandatory */
-  /* c3. Cause */
-  asn1cSequenceAdd(out->protocolIEs.list, F1AP_UEContextReleaseRequestIEs_t, ie3);
-  ie3->id                             = F1AP_ProtocolIE_ID_id_Cause;
-  ie3->criticality                    = F1AP_Criticality_ignore;
-  ie3->value.present                  = F1AP_UEContextReleaseRequestIEs__value_PR_Cause;
 
-  switch (req->cause) {
+  uint8_t *buffer = NULL;
-    case F1AP_CAUSE_RADIO_NETWORK:
+  uint32_t len = 0;
-      ie3->value.choice.Cause.present = F1AP_Cause_PR_radioNetwork;
+  if (f1ap_encode_pdu(pdu, &buffer, &len) < 0) {
-      ie3->value.choice.Cause.choice.radioNetwork = req->cause_value;
-      break;
-
-    case F1AP_CAUSE_TRANSPORT:
-      ie3->value.choice.Cause.present = F1AP_Cause_PR_transport;
-      ie3->value.choice.Cause.choice.transport = req->cause_value;
-      break;
-
-    case F1AP_CAUSE_PROTOCOL:
-      ie3->value.choice.Cause.present = F1AP_Cause_PR_protocol;
-      ie3->value.choice.Cause.choice.protocol = req->cause_value;
-      break;
-
-    case F1AP_CAUSE_MISC:
-      ie3->value.choice.Cause.present = F1AP_Cause_PR_misc;
-      ie3->value.choice.Cause.choice.misc = req->cause_value;
-      break;
-
-    case F1AP_CAUSE_NOTHING:
-    default:
-      ie3->value.choice.Cause.present = F1AP_Cause_PR_NOTHING;
-      break;
-  }
-
-  /* encode */
-  if (f1ap_encode_pdu(&pdu, &buffer, &len) < 0) {
     LOG_E(F1AP, "Failed to encode F1 context release request\n");
     return -1;
   }
 
   f1ap_itti_send_sctp_data_req(assoc_id, buffer, len);
+  ASN_STRUCT_FREE(asn_DEF_F1AP_F1AP_PDU, pdu);
   return 0;
 }
 
@@ -153,8 +97,8 @@ int DU_handle_UE_CONTEXT_RELEASE_COMMAND(instance_t instance, sctp_assoc_t assoc
   F1AP_UEContextReleaseCommand_t *container;
   F1AP_UEContextReleaseCommandIEs_t *ie;
 
-  f1ap_ue_context_release_req_t ue_context_release = {0};
+  f1ap_ue_context_release_cmd_t ue_context_release = {0};
-  f1ap_ue_context_release_req_t *f1ap_ue_context_release_cmd = &ue_context_release;
+  f1ap_ue_context_release_cmd_t *f1ap_ue_context_release_cmd = &ue_context_release;
 
   DevAssert(pdu);
   container = &pdu->choice.initiatingMessage->value.choice.UEContextReleaseCommand;

openair2/F1AP/f1ap_du_ue_context_management.h

@@ -45,9 +45,7 @@ int DU_send_UE_CONTEXT_SETUP_FAILURE(sctp_assoc_t assoc_id);
 /*
  * UE Context Release Request (gNB-DU initiated)
  */
-int DU_send_UE_CONTEXT_RELEASE_REQUEST(sctp_assoc_t assoc_id,
+int DU_send_UE_CONTEXT_RELEASE_REQUEST(sctp_assoc_t assoc_id, f1ap_ue_context_rel_req_t *req);
-                                       f1ap_ue_context_release_req_t *req);
-
 
 /*
  * UE Context Release Command (gNB-CU initiated)

openair2/LAYER2/NR_MAC_gNB/gNB_scheduler_primitives.c

@@ -3385,7 +3385,7 @@ bool nr_mac_request_release_ue(const gNB_MAC_INST *nrmac, int rnti)
     return false;
   }
   f1_ue_data_t ue_data = du_get_f1_ue_data(rnti);
-  f1ap_ue_context_release_req_t request = {
+  f1ap_ue_context_rel_req_t request = {
     .gNB_CU_ue_id = ue_data.secondary_ue,
     .gNB_DU_ue_id = rnti,
     .cause = F1AP_CAUSE_RADIO_NETWORK,

openair2/LAYER2/NR_MAC_gNB/mac_rrc_dl_handler.c

@@ -852,7 +852,7 @@ void ue_context_modification_refuse(const f1ap_ue_context_modif_refuse_t *refuse
 
   NR_SCHED_UNLOCK(&mac->sched_lock);
 
-  f1ap_ue_context_release_req_t request = {
+  f1ap_ue_context_rel_req_t request = {
     .gNB_CU_ue_id = refuse->gNB_CU_ue_id,
     .gNB_DU_ue_id = refuse->gNB_DU_ue_id,
     .cause = F1AP_CAUSE_RADIO_NETWORK,

openair2/LAYER2/NR_MAC_gNB/mac_rrc_ul.h

@@ -34,7 +34,7 @@ typedef void (*gnb_du_configuration_update_t)(const f1ap_gnb_du_configuration_up
 typedef void (*ue_context_setup_response_func_t)(const f1ap_ue_context_setup_resp_t *resp);
 typedef void (*ue_context_modification_response_func_t)(const f1ap_ue_context_mod_resp_t *resp);
 typedef void (*ue_context_modification_required_func_t)(const f1ap_ue_context_modif_required_t *t);
-typedef void (*ue_context_release_request_func_t)(const f1ap_ue_context_release_req_t* req);
+typedef void (*ue_context_release_request_func_t)(const f1ap_ue_context_rel_req_t* req);
 typedef void (*ue_context_release_complete_func_t)(const f1ap_ue_context_release_complete_t *complete);
 
 typedef void (*initial_ul_rrc_message_transfer_func_t)(module_id_t module_id, const f1ap_initial_ul_rrc_message_t *ul_rrc);

openair2/LAYER2/NR_MAC_gNB/mac_rrc_ul_direct.c

@@ -101,12 +101,11 @@ static void ue_context_modification_required_direct(const f1ap_ue_context_modif_
   itti_send_msg_to_task(TASK_RRC_GNB, 0, msg);
 }
 
-static void ue_context_release_request_direct(const f1ap_ue_context_release_req_t* req)
+static void ue_context_release_request_direct(const f1ap_ue_context_rel_req_t* req)
 {
   MessageDef *msg = itti_alloc_new_message(TASK_MAC_GNB, 0, F1AP_UE_CONTEXT_RELEASE_REQ);
   msg->ittiMsgHeader.originInstance = -1; // means monolithic
-  f1ap_ue_context_release_req_t *f1ap_msg = &F1AP_UE_CONTEXT_RELEASE_REQ(msg);
+  F1AP_UE_CONTEXT_RELEASE_REQ(msg) = cp_ue_context_rel_req(req);
-  *f1ap_msg = *req;
   itti_send_msg_to_task(TASK_RRC_GNB, 0, msg);
 }
 

openair2/LAYER2/NR_MAC_gNB/mac_rrc_ul_f1ap.c

@@ -125,11 +125,10 @@ static void ue_context_modification_required_f1ap(const f1ap_ue_context_modif_re
   itti_send_msg_to_task(TASK_DU_F1, 0, msg);
 }
 
-static void ue_context_release_request_f1ap(const f1ap_ue_context_release_req_t* req)
+static void ue_context_release_request_f1ap(const f1ap_ue_context_rel_req_t* req)
 {
   MessageDef *msg = itti_alloc_new_message(TASK_MAC_GNB, 0, F1AP_UE_CONTEXT_RELEASE_REQ);
-  f1ap_ue_context_release_req_t *f1ap_msg = &F1AP_UE_CONTEXT_RELEASE_REQ(msg);
+  F1AP_UE_CONTEXT_RELEASE_REQ(msg) = cp_ue_context_rel_req(req);
-  *f1ap_msg = *req;
   itti_send_msg_to_task(TASK_DU_F1, 0, msg);
 }
 

openair2/RRC/NR/rrc_gNB.c

@@ -2133,7 +2133,7 @@ static void rrc_CU_process_ue_context_setup_response(MessageDef *msg_p, instance
 static void rrc_CU_process_ue_context_release_request(MessageDef *msg_p, sctp_assoc_t assoc_id)
 {
   const int instance = 0;
-  f1ap_ue_context_release_req_t *req = &F1AP_UE_CONTEXT_RELEASE_REQ(msg_p);
+  f1ap_ue_context_rel_req_t *req = &F1AP_UE_CONTEXT_RELEASE_REQ(msg_p);
   gNB_RRC_INST *rrc = RC.nrrrc[instance];
   rrc_gNB_ue_context_t *ue_context_p = rrc_gNB_get_ue_context(rrc, req->gNB_CU_ue_id);
   // TODO what happens if no AMF connected? should also handle, set an_release true
@@ -2775,6 +2775,7 @@ void *rrc_gnb_task(void *args_p) {
 
       case F1AP_UE_CONTEXT_RELEASE_REQ:
         rrc_CU_process_ue_context_release_request(msg_p, msg_p->ittiMsgHeader.originInstance);
+        free_ue_context_rel_req(&F1AP_UE_CONTEXT_RELEASE_REQ(msg_p));
         break;
 
       case F1AP_UE_CONTEXT_RELEASE_COMPLETE: