Merge remote-tracking branch 'origin/int-f1-ue-ids' into integration_2023_w32

CMakeLists.txt

@@ -413,6 +413,7 @@ target_link_libraries(x2ap PRIVATE asn1_lte_rrc_hdrs asn1_nr_rrc_hdrs)
 set(F1AP_DIR ${OPENAIR2_DIR}/F1AP)
 add_library(f1ap
             ${F1AP_DIR}/f1ap_common.c
+            ${F1AP_DIR}/f1ap_ids.c
             ${F1AP_DIR}/f1ap_cu_interface_management.c
             ${F1AP_DIR}/f1ap_cu_paging.c
             ${F1AP_DIR}/f1ap_cu_rrc_message_transfer.c
@@ -431,7 +432,7 @@ add_library(f1ap
             ${F1AP_DIR}/f1ap_itti_messaging.c)
 target_include_directories(f1ap PUBLIC F1AP_DIR)
 target_link_libraries(f1ap PUBLIC asn1_f1ap)
-target_link_libraries(f1ap PRIVATE ngap nr_rrc)
+target_link_libraries(f1ap PRIVATE ngap nr_rrc HASHTABLE)
 
 # LPP
 ##############

ci-scripts/xml_files/container_sa_b200_quectel.xml

@@ -111,7 +111,7 @@
   <testCase id="000002">
     <class>IdleSleep</class>
     <desc>Sleep</desc>
-    <idle_sleep_time_in_sec>20</idle_sleep_time_in_sec>
+    <idle_sleep_time_in_sec>10</idle_sleep_time_in_sec>
   </testCase>
 
 
@@ -168,14 +168,14 @@
     <class>Custom_Command</class>
     <desc>Trigger Reestablishment</desc>
     <node>ofqot</node>
-    <command>echo ci force_reestab | nc -N 192.168.68.194 9090 | grep -E 'force-remove UE RNTI [0-9a-f]{4} from RLC to trigger reestablishment'</command>
+    <command>echo ci force_reestab | nc -N 192.168.68.194 9090 | grep -E 'Reset RLC counters of UE RNTI [0-9a-f]{4} to trigger reestablishment'</command>
     <command_fail>yes</command_fail>
   </testCase>
   <testCase id="060002">
     <class>Custom_Command</class>
     <desc>Verify Reestablishment</desc>
     <node>ofqot</node>
-    <command>echo ci get_reestab_count | nc -N 192.168.68.194 9090 | grep -E 'UE RNTI [0-9a-f]{4} reestab 1 reconf_after_reestab 1'</command>
+    <command>echo ci get_reestab_count | nc -N 192.168.68.194 9090 | grep -E 'UE RNTI [0-9a-f]{4} reestab 1'</command>
     <command_fail>yes</command_fail>
   </testCase>
 

ci-scripts/xml_files/container_sa_f1_b200_quectel.xml

@@ -39,6 +39,10 @@
     110011
     110001
     150001
+    160001
+    100002
+    160002
+    150001
     110011
     110001
     150000
@@ -114,7 +118,7 @@
   <testCase id="100002">
     <class>IdleSleep</class>
     <desc>Sleep</desc>
-    <idle_sleep_time_in_sec>20</idle_sleep_time_in_sec>
+    <idle_sleep_time_in_sec>10</idle_sleep_time_in_sec>
   </testCase>
 
   <testCase id="150000">
@@ -184,6 +188,21 @@
     <iperf_profile>single-ue</iperf_profile>
   </testCase>
 
+  <testCase id="160001">
+    <class>Custom_Command</class>
+    <desc>Trigger Reestablishment (on DU)</desc>
+    <node>ofqot</node>
+    <command>echo ci force_reestab | nc -N 192.168.68.195 9090 | grep -E 'Reset RLC counters of UE RNTI [0-9a-f]{4} to trigger reestablishment'</command>
+    <command_fail>yes</command_fail>
+  </testCase>
+  <testCase id="160002">
+    <class>Custom_Command</class>
+    <desc>Verify Reestablishment (on CU)</desc>
+    <node>ofqot</node>
+    <command>echo ci get_reestab_count | nc -N 192.168.68.194 9090 | grep -E 'UE RNTI [0-9a-f]{4} reestab 1'</command>
+    <command_fail>yes</command_fail>
+  </testCase>
+
   <testCase id="130201">
     <class>Undeploy_Object</class>
     <desc>Undeploy CU-DU</desc>

ci-scripts/xml_files/container_sa_sc_b200_quectel.xml

@@ -105,7 +105,7 @@
   <testCase id="200002">
     <class>IdleSleep</class>
     <desc>Sleep</desc>
-    <idle_sleep_time_in_sec>20</idle_sleep_time_in_sec>
+    <idle_sleep_time_in_sec>10</idle_sleep_time_in_sec>
   </testCase>
 
 
@@ -162,14 +162,14 @@
     <class>Custom_Command</class>
     <desc>Trigger Reestablishment</desc>
     <node>ofqot</node>
-    <command>echo ci force_reestab | nc -N 192.168.68.194 9090 | grep -E 'force-remove UE RNTI [0-9a-f]{4} from RLC to trigger reestablishment'</command>
+    <command>echo ci force_reestab | nc -N 192.168.68.194 9090 | grep -E 'Reset RLC counters of UE RNTI [0-9a-f]{4} to trigger reestablishment'</command>
     <command_fail>yes</command_fail>
   </testCase>
   <testCase id="260002">
     <class>Custom_Command</class>
     <desc>Verify Reestablishment</desc>
     <node>ofqot</node>
-    <command>echo ci get_reestab_count | nc -N 192.168.68.194 9090 | grep -E 'UE RNTI [0-9a-f]{4} reestab 1 reconf_after_reestab 1'</command>
+    <command>echo ci get_reestab_count | nc -N 192.168.68.194 9090 | grep -E 'UE RNTI [0-9a-f]{4} reestab 1'</command>
     <command_fail>yes</command_fail>
   </testCase>
 

ci-scripts/yaml_files/sa_f1_b200_gnb/docker-compose.yml

@@ -6,7 +6,7 @@ services:
         privileged: true
         container_name: sa-cu-gnb
         environment:
-            USE_ADDITIONAL_OPTIONS: --sa --log_config.global_log_options level,nocolor,time,line_num,function
+            USE_ADDITIONAL_OPTIONS: --sa --telnetsrv --telnetsrv.shrmod ci --log_config.global_log_options level,nocolor,time,line_num,function
         volumes:
             - ../../conf_files/gnb-cu.sa.band78.106prb.usrpb200.conf:/opt/oai-gnb/etc/gnb.conf
         networks:
@@ -26,7 +26,7 @@ services:
         container_name: sa-du-b200-gnb
         environment:
             USE_B2XX: 'yes'
-            USE_ADDITIONAL_OPTIONS: --sa --RUs.[0].sdr_addrs serial=30C51D4 --continuous-tx -E --log_config.global_log_options level,nocolor,time,line_num,function --gNBs.[0].min_rxtxtime 2 --gNBs.[0].do_CSIRS 1 --gNBs.[0].do_SRS 1 --RUs.[0].att_rx 14 --RUs.[0].att_tx 14
+            USE_ADDITIONAL_OPTIONS: --sa --RUs.[0].sdr_addrs serial=30C51D4 --continuous-tx -E --telnetsrv --telnetsrv.shrmod ci --log_config.global_log_options level,nocolor,time,line_num,function --gNBs.[0].min_rxtxtime 2 --gNBs.[0].do_CSIRS 1 --gNBs.[0].do_SRS 1 --RUs.[0].att_rx 14 --RUs.[0].att_tx 14
         volumes:
             - ../../conf_files/gnb-du.sa.band78.106prb.usrpb200.conf:/opt/oai-gnb/etc/gnb.conf
             - /dev:/dev

common/utils/telnetsrv/telnetsrv_ci.c

@@ -28,15 +28,17 @@
 #include <stdarg.h>
 
 #include "openair2/RRC/NR/rrc_gNB_UE_context.h"
-#include "openair2/LAYER2/nr_rlc/nr_rlc_oai_api.h"
 #include "openair2/LAYER2/NR_MAC_gNB/nr_mac_gNB.h"
+#include "openair2/LAYER2/nr_rlc/nr_rlc_oai_api.h"
+#include "openair2/LAYER2/nr_rlc/nr_rlc_ue_manager.h"
+#include "openair2/LAYER2/nr_rlc/nr_rlc_entity_am.h"
 
 #define TELNETSERVERCODE
 #include "telnetsrv.h"
 
 #define ERROR_MSG_RET(mSG, aRGS...) do { prnt(mSG, ##aRGS); return 1; } while (0)
 
-static int get_single_ue_rnti(void)
+static int get_single_ue_rnti_mac(void)
 {
   NR_UE_info_t *ue = NULL;
   UE_iterator(RC.nrmac[0]->UE_info.list, it) {
@@ -48,11 +50,6 @@ static int get_single_ue_rnti(void)
   if (!ue)
     return -1;
 
-  // verify it exists in RRC as well
-  rrc_gNB_ue_context_t *rrcue = rrc_gNB_get_ue_context_by_rnti(RC.nrrrc[0], ue->rnti);
-  if (!rrcue)
-    return -1;
-
   return ue->rnti;
 }
 
@@ -61,7 +58,7 @@ int get_single_rnti(char *buf, int debug, telnet_printfunc_t prnt)
   if (buf)
     ERROR_MSG_RET("no parameter allowed\n");
 
-  int rnti = get_single_ue_rnti();
+  int rnti = get_single_ue_rnti_mac();
   if (rnti < 1)
     ERROR_MSG_RET("different number of UEs\n");
 
@@ -71,23 +68,32 @@ int get_single_rnti(char *buf, int debug, telnet_printfunc_t prnt)
 
 int get_reestab_count(char *buf, int debug, telnet_printfunc_t prnt)
 {
+  if (!RC.nrrrc)
+    ERROR_MSG_RET("no RRC present, cannot list counts\n");
+  rrc_gNB_ue_context_t *ue = NULL;
   int rnti = -1;
   if (!buf) {
-    rnti = get_single_ue_rnti();
-    if (rnti < 1)
-      ERROR_MSG_RET("no UE found\n");
+    rrc_gNB_ue_context_t *l = NULL;
+    int n = 0;
+    RB_FOREACH(l, rrc_nr_ue_tree_s, &RC.nrrrc[0]->rrc_ue_head) {
+      if (ue == NULL) ue = l;
+      n++;
+    }
+    if (!ue)
+      ERROR_MSG_RET("could not find any UE in RRC\n");
+    if (n > 1)
+      ERROR_MSG_RET("more than one UE in RRC present\n");
   } else {
     rnti = strtol(buf, NULL, 16);
     if (rnti < 1 || rnti >= 0xfffe)
       ERROR_MSG_RET("RNTI needs to be [1,0xfffe]\n");
+    ue = rrc_gNB_get_ue_context_by_rnti(RC.nrrrc[0], rnti);
+    if (!ue)
+      ERROR_MSG_RET("could not find UE with RNTI %04x in RRC\n");
   }
 
-  rrc_gNB_ue_context_t *ue = rrc_gNB_get_ue_context_by_rnti(RC.nrrrc[0], rnti);
-  if (!ue)
-    ERROR_MSG_RET("could not find UE with RNTI %04x\n", rnti);
-
   prnt("UE RNTI %04x reestab %d reconf_after_reestab %d\n",
-       rnti,
+       ue->ue_context.rnti,
        ue->ue_context.ue_reestablishment_counter,
        ue->ue_context.ue_reconfiguration_after_reestablishment_counter);
   return 0;
@@ -95,9 +101,11 @@ int get_reestab_count(char *buf, int debug, telnet_printfunc_t prnt)
 
 int trigger_reestab(char *buf, int debug, telnet_printfunc_t prnt)
 {
+  if (!RC.nrmac)
+    ERROR_MSG_RET("no MAC/RLC present, cannot trigger reestablishment\n");
   int rnti = -1;
   if (!buf) {
-    rnti = get_single_ue_rnti();
+    rnti = get_single_ue_rnti_mac();
     if (rnti < 1)
       ERROR_MSG_RET("no UE found\n");
   } else {
@@ -106,13 +114,9 @@ int trigger_reestab(char *buf, int debug, telnet_printfunc_t prnt)
       ERROR_MSG_RET("RNTI needs to be [1,0xfffe]\n");
   }
 
-  // verify it exists in RRC as well
-  rrc_gNB_ue_context_t *rrcue = rrc_gNB_get_ue_context_by_rnti(RC.nrrrc[0], rnti);
-  if (!rrcue)
-    ERROR_MSG_RET("could not find UE with RNTI %04x\n", rnti);
+  nr_rlc_test_trigger_reestablishment(rnti);
 
-  nr_rlc_remove_ue(rnti);
-  prnt("force-remove UE RNTI %04x from RLC to trigger reestablishment\n", rnti);
+  prnt("Reset RLC counters of UE RNTI %04x to trigger reestablishment\n", rnti);
   return 0;
 }
 

executables/nr-cuup.c

@@ -27,6 +27,7 @@
 #include "common/ran_context.h"
 #include "nfapi/oai_integration/vendor_ext.h"
 #include "openair2/F1AP/f1ap_common.h"
+#include "openair2/F1AP/f1ap_ids.h"
 #include "openair2/GNB_APP/gnb_config.h"
 #include "nr_pdcp/nr_pdcp_oai_api.h"
 
@@ -134,6 +135,7 @@ int main(int argc, char **argv)
   rc = itti_create_task(TASK_CUUP_E1, E1AP_CUUP_task, NULL);
   AssertFatal(rc >= 0, "Create task for CUUP E1 failed\n");
   nr_pdcp_layer_init();
+  cu_init_f1_ue_data(); // for CU-UP/CP mapping: we use the same
   MessageDef *msg = RCconfig_NR_CU_E1(true);
   AssertFatal(msg != NULL, "Send init to task for E1AP UP failed\n");
   itti_send_msg_to_task(TASK_CUUP_E1, 0, msg);

openair2/COMMON/e1ap_messages_types.h

@@ -156,7 +156,6 @@ typedef struct pdu_session_to_setup_s {
 typedef struct e1ap_bearer_setup_req_s {
   uint32_t gNB_cu_cp_ue_id;
   uint32_t gNB_cu_up_ue_id;
-  rnti_t   rnti;
   uint64_t cipheringAlgorithm;
   uint64_t integrityProtectionAlgorithm;
   char     encryptionKey[128];
@@ -216,8 +215,8 @@ typedef struct pdu_session_setup_s {
 } pdu_session_setup_t;
 
 typedef struct e1ap_bearer_setup_resp_s {
-  uint64_t gNB_cu_cp_ue_id;
-  uint64_t gNB_cu_up_ue_id;
+  uint32_t gNB_cu_cp_ue_id;
+  uint32_t gNB_cu_up_ue_id;
   int numDRBs;
   drb_setup_t DRBList[E1AP_MAX_NUM_DRBS];
   int numPDUSessions;

openair2/COMMON/f1ap_messages_types.h

@@ -286,8 +286,7 @@ typedef struct f1ap_dl_rrc_message_s {
 
   uint32_t gNB_CU_ue_id;
   uint32_t gNB_DU_ue_id;
-  uint32_t old_gNB_DU_ue_id;
-  uint16_t rnti; 
+  uint32_t *old_gNB_DU_ue_id;
   uint8_t  srb_id;
   uint8_t  execute_duplication;
   uint8_t *rrc_container;
@@ -318,7 +317,8 @@ typedef struct f1ap_initial_ul_rrc_message_s {
 } f1ap_initial_ul_rrc_message_t;
 
 typedef struct f1ap_ul_rrc_message_s {
-  uint16_t rnti;
+  uint32_t gNB_CU_ue_id;
+  uint32_t gNB_DU_ue_id;
   uint8_t  srb_id;
   uint8_t *rrc_container;
   int      rrc_container_length;
@@ -378,9 +378,8 @@ typedef enum ReconfigurationCompl_e {
 } ReconfigurationCompl_t;
 
 typedef struct f1ap_ue_context_setup_s {
-  uint32_t gNB_CU_ue_id;    // BK: need to replace by use from rnti
+  uint32_t gNB_CU_ue_id;
   uint32_t gNB_DU_ue_id;
-  uint16_t rnti; 
   // SpCell Info
   uint16_t mcc;
   uint16_t mnc;
@@ -419,7 +418,8 @@ typedef enum F1ap_Cause_e {
 } f1ap_Cause_t;
 
 typedef struct f1ap_ue_context_release_s {
-  uint16_t      rnti;
+  uint32_t gNB_CU_ue_id;
+  uint32_t gNB_DU_ue_id;
   f1ap_Cause_t  cause;
   long          cause_value;
   uint8_t      *rrc_container;

openair2/E1AP/e1ap.c

@@ -1095,7 +1095,7 @@ static int fill_BEARER_CONTEXT_MODIFICATION_REQUEST(e1ap_setup_req_t *setupReq,
   ieC2->id                         = E1AP_ProtocolIE_ID_id_gNB_CU_UP_UE_E1AP_ID;
   ieC2->criticality                = E1AP_Criticality_reject;
   ieC2->value.present              = E1AP_BearerContextModificationRequestIEs__value_PR_GNB_CU_UP_UE_E1AP_ID;
-  ieC2->value.choice.GNB_CU_UP_UE_E1AP_ID = bearerCxt->gNB_cu_cp_ue_id;
+  ieC2->value.choice.GNB_CU_UP_UE_E1AP_ID = bearerCxt->gNB_cu_up_ue_id;
   /* optional */
   /*  */
   asn1cSequenceAdd(out->protocolIEs.list, E1AP_BearerContextModificationRequestIEs_t, ieC3);

openair2/E1AP/e1ap_api.c

@@ -30,6 +30,7 @@
 #include "openair2/RRC/LTE/MESSAGES/asn1_msg.h"
 #include "openair3/SECU/key_nas_deriver.h"
 #include "openair3/ocp-gtpu/gtp_itf.h"
+#include "openair2/F1AP/f1ap_ids.h"
 #include "e1ap_asnc.h"
 #include "e1ap_common.h"
 #include "e1ap.h"
@@ -109,7 +110,7 @@ static int drb_config_N3gtpu_create(e1ap_bearer_setup_req_t * const req,
     fill_DRB_configList_e1(&DRB_configList, pdu);
   }
   create_tunnel_req.num_tunnels = req->numPDUSessions;
-  create_tunnel_req.ue_id = (req->gNB_cu_cp_ue_id & 0xFFFF);
+  create_tunnel_req.ue_id = req->gNB_cu_cp_ue_id;
 
   // Create N3 tunnel
   int ret = gtpv1u_create_ngu_tunnel(instance, &create_tunnel_req, create_tunnel_resp, nr_pdcp_data_req_drb, sdap_data_req);
@@ -136,6 +137,11 @@ void process_e1_bearer_context_setup_req(instance_t instance, e1ap_bearer_setup_
   AssertFatal(inst, "");
   gtpv1u_gnb_create_tunnel_resp_t create_tunnel_resp_N3={0};
 
+  uint32_t gNB_cu_up_ue_id = req ->gNB_cu_cp_ue_id;
+  LOG_I(E1AP, "adding UE with CU-CP UE ID %d and CU-UP UE ID %d\n", req->gNB_cu_cp_ue_id, gNB_cu_up_ue_id);
+  f1_ue_data_t ue_data = {.secondary_ue = req->gNB_cu_cp_ue_id};
+  cu_add_f1_ue_data(gNB_cu_up_ue_id, &ue_data);
+
   // GTP tunnel for UL
   drb_config_N3gtpu_create(req, &create_tunnel_resp_N3, inst->gtpInstN3);
 
@@ -148,6 +154,7 @@ void process_e1_bearer_context_setup_req(instance_t instance, e1ap_bearer_setup_
   fill_e1ap_bearer_setup_resp(resp, req, inst->gtpInstF1U, req->gNB_cu_cp_ue_id, inst->setupReq.remotePortF1U, my_addr);
 
   resp->gNB_cu_cp_ue_id = req->gNB_cu_cp_ue_id;
+  resp->gNB_cu_up_ue_id = gNB_cu_up_ue_id;
   resp->numPDUSessions = req->numPDUSessions;
   for (int i=0; i < req->numPDUSessions; i++) {
     pdu_session_setup_t *pduSetup = resp->pduSession + i;

openair2/F1AP/CMakeLists.txt

 add_subdirectory(MESSAGES)
+
+if(ENABLE_TESTS)
+  add_executable(f1ap_ids_test f1ap_ids_test.c f1ap_ids.c)
+  target_link_libraries(f1ap_ids_test UTIL HASHTABLE minimal_lib)
+  add_dependencies(tests f1ap_ids_test)
+  add_test(NAME F1AP_ID_test COMMAND f1ap_ids_test)
+endif()

openair2/F1AP/f1ap_common.c

@@ -66,123 +66,6 @@ void createF1inst(F1_t isCU, instance_t instanceP, f1ap_setup_req_t *req) {
   }
 }
 
-int f1ap_add_ue(F1_t isCu,
-                instance_t          instanceP,
-                rnti_t               rntiP) {
-  f1ap_cudu_inst_t *f1_inst=getCxt(isCu, instanceP);
-
-  for (int i = 0; i < MAX_MOBILES_PER_GNB; i++) {
-    if (f1_inst->f1ap_ue[i].rnti == rntiP) {
-      f1_inst->f1ap_ue[i].f1ap_uid = i;
-      LOG_I(F1AP, "Updating the index of UE with RNTI %x and du_ue_f1ap_id %ld\n", f1_inst->f1ap_ue[i].rnti, f1_inst->f1ap_ue[i].du_ue_f1ap_id);
-      return i;
-    }
-  }
-
-  // We didn't find the rnti
-  for (int i = 0; i < MAX_MOBILES_PER_GNB; i++) {
-    if (f1_inst->f1ap_ue[i].rnti == 0 ) {
-      f1_inst->f1ap_ue[i].rnti = rntiP;
-      f1_inst->f1ap_ue[i].f1ap_uid = i;
-      f1_inst->f1ap_ue[i].du_ue_f1ap_id = rntiP;
-      f1_inst->f1ap_ue[i].cu_ue_f1ap_id = rntiP;
-      f1_inst->num_ues++;
-      LOG_I(F1AP, "Adding a new UE with RNTI %x and cu/du ue_f1ap_id %ld\n", f1_inst->f1ap_ue[i].rnti, f1_inst->f1ap_ue[i].du_ue_f1ap_id);
-      return i;
-    }
-  }
-
-  return -1;
-}
-
-
-int f1ap_remove_ue(F1_t isCu, instance_t instanceP,
-                   rnti_t            rntiP) {
-  f1ap_cudu_inst_t *f1_inst=getCxt(isCu, instanceP);
-
-  for (int i = 0; i < MAX_MOBILES_PER_GNB; i++) {
-    if (f1_inst->f1ap_ue[i].rnti == rntiP) {
-      f1_inst->f1ap_ue[i].rnti = 0;
-      break;
-    }
-  }
-
-  f1_inst->num_ues--;
-  return 0;
-}
-
-int f1ap_get_du_ue_f1ap_id(F1_t isCu, instance_t instanceP,
-                           rnti_t            rntiP) {
-  f1ap_cudu_inst_t *f1_inst=getCxt(isCu, instanceP);
-
-  for (int i = 0; i < MAX_MOBILES_PER_GNB; i++) {
-    if (f1_inst->f1ap_ue[i].rnti == rntiP) {
-      return f1_inst->f1ap_ue[i].du_ue_f1ap_id;
-    }
-  }
-
-  return -1;
-}
-
-int f1ap_get_cu_ue_f1ap_id(F1_t isCu, instance_t instanceP,
-                           rnti_t            rntiP) {
-  f1ap_cudu_inst_t *f1_inst=getCxt(isCu, instanceP);
-
-  for (int i = 0; i < MAX_MOBILES_PER_GNB; i++) {
-    if (f1_inst->f1ap_ue[i].rnti == rntiP) {
-      return f1_inst->f1ap_ue[i].cu_ue_f1ap_id;
-    }
-  }
-
-  return -1;
-}
-
-int f1ap_get_rnti_by_du_id(F1_t isCu, instance_t instanceP,
-                           instance_t       du_ue_f1ap_id ) {
-  f1ap_cudu_inst_t *f1_inst=getCxt(isCu, instanceP);
-
-  for (int i = 0; i < MAX_MOBILES_PER_GNB; i++) {
-    if (f1_inst->f1ap_ue[i].du_ue_f1ap_id == du_ue_f1ap_id) {
-      return f1_inst->f1ap_ue[i].rnti;
-    }
-  }
-
-  return -1;
-}
-
-int f1ap_get_rnti_by_cu_id(F1_t isCu, instance_t instanceP,
-                           instance_t       cu_ue_f1ap_id ) {
-  f1ap_cudu_inst_t *f1_inst=getCxt(isCu, instanceP);
-
-  for (int i = 0; i < MAX_MOBILES_PER_GNB; i++) {
-    if (f1_inst->f1ap_ue[i].cu_ue_f1ap_id == cu_ue_f1ap_id) {
-      return f1_inst->f1ap_ue[i].rnti;
-    }
-  }
-
-  return -1;
-}
-
-int f1ap_du_add_cu_ue_id(instance_t instanceP,
-                         instance_t       du_ue_f1ap_id,
-                         instance_t       cu_ue_f1ap_id) {
-  f1ap_cudu_inst_t *f1_inst=getCxt(DUtype, instanceP);
-  instance_t f1ap_uid=-1;
-
-  for (int i = 0; i < MAX_MOBILES_PER_GNB; i++) {
-    if (f1_inst->f1ap_ue[i].du_ue_f1ap_id == du_ue_f1ap_id) {
-      f1ap_uid=i;
-      break;
-    }
-  }
-
-  if (f1ap_uid < 0 || f1ap_uid >= MAX_MOBILES_PER_GNB)
-    return -1;
-
-  f1_inst->f1ap_ue[f1ap_uid].cu_ue_f1ap_id = cu_ue_f1ap_id;
-  LOG_D(F1AP, "Adding cu_ue_f1ap_id %ld for UE with RNTI %x\n", cu_ue_f1ap_id, f1_inst->f1ap_ue[f1ap_uid].rnti);
-  return 0;
-}
 
 int f1ap_assoc_id(F1_t isCu, instance_t instanceP) {
   f1ap_setup_req_t *f1_inst=f1ap_req(isCu, instanceP);

openair2/F1AP/f1ap_common.h

@@ -427,30 +427,6 @@ uint8_t F1AP_get_next_transaction_identifier(instance_t mod_idP, instance_t cu_m
 f1ap_cudu_inst_t *getCxt(F1_t isCU, instance_t instanceP);
 
 void createF1inst(F1_t isCU, instance_t instanceP, f1ap_setup_req_t *req);
-int f1ap_add_ue(F1_t isCu,
-                instance_t     instanceP,
-                rnti_t          rntiP);
-
-int f1ap_remove_ue(F1_t isCu, instance_t instanceP,
-                   rnti_t            rntiP);
-
-int f1ap_get_du_ue_f1ap_id (F1_t isCu, instance_t instanceP,
-                            rnti_t            rntiP);
-
-int f1ap_get_cu_ue_f1ap_id (F1_t isCu, instance_t instanceP,
-                            rnti_t            rntiP);
-
-
-int f1ap_get_rnti_by_du_id(F1_t isCu, instance_t instanceP,
-                           instance_t       du_ue_f1ap_id );
-
-
-int f1ap_get_rnti_by_cu_id(F1_t isCu, instance_t instanceP,
-                           instance_t       cu_ue_f1ap_id );
-
-int f1ap_du_add_cu_ue_id(instance_t instanceP,
-                         instance_t       du_ue_f1ap_id,
-                         instance_t       cu_ue_f1ap_id);
 
 int f1ap_assoc_id(F1_t isCu, instance_t instanceP);
 

openair2/F1AP/f1ap_cu_rrc_message_transfer.c

@@ -32,6 +32,7 @@
 
 #include "f1ap_common.h"
 #include "f1ap_encoder.h"
+#include "f1ap_ids.h"
 #include "f1ap_itti_messaging.h"
 #include "f1ap_cu_rrc_message_transfer.h"
 #include "common/ran_context.h"
@@ -53,9 +54,6 @@ int CU_handle_INITIAL_UL_RRC_MESSAGE_TRANSFER(instance_t             instance,
   MessageDef                            *message_p;
   F1AP_InitialULRRCMessageTransfer_t    *container;
   F1AP_InitialULRRCMessageTransferIEs_t *ie;
-  rnti_t          rnti;
-  sdu_size_t      ccch_sdu_len;
-  int             CC_id =0;
   DevAssert(pdu != NULL);
 
   if (stream != 0) {
@@ -68,6 +66,8 @@ int CU_handle_INITIAL_UL_RRC_MESSAGE_TRANSFER(instance_t             instance,
   /* GNB_DU_UE_F1AP_ID */
   F1AP_FIND_PROTOCOLIE_BY_ID(F1AP_InitialULRRCMessageTransferIEs_t, ie, container,
                              F1AP_ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID, true);
+  uint32_t du_ue_id = ie->value.choice.GNB_DU_UE_F1AP_ID;
+
   /* NRCGI
   * Fixme: process NRCGI
   */
@@ -78,7 +78,7 @@ int CU_handle_INITIAL_UL_RRC_MESSAGE_TRANSFER(instance_t             instance,
   /* RNTI */
   F1AP_FIND_PROTOCOLIE_BY_ID(F1AP_InitialULRRCMessageTransferIEs_t, ie, container,
                              F1AP_ProtocolIE_ID_id_C_RNTI, true);
-  rnti = ie->value.choice.C_RNTI;
+  rnti_t rnti = ie->value.choice.C_RNTI;
   F1AP_InitialULRRCMessageTransferIEs_t *rrccont;
   F1AP_FIND_PROTOCOLIE_BY_ID(F1AP_InitialULRRCMessageTransferIEs_t, rrccont, container,
                              F1AP_ProtocolIE_ID_id_RRCContainer, true);
@@ -88,51 +88,22 @@ int CU_handle_INITIAL_UL_RRC_MESSAGE_TRANSFER(instance_t             instance,
   F1AP_FIND_PROTOCOLIE_BY_ID(F1AP_InitialULRRCMessageTransferIEs_t, du2cu, container,
                              F1AP_ProtocolIE_ID_id_DUtoCURRCContainer, false);
 
-  int f1ap_uid = f1ap_add_ue(CUtype, instance, rnti);
-
-  if (f1ap_uid  < 0 ) {
-    LOG_E(F1AP, "Failed to add UE \n");
-    return -1;
-  }
-
   // create an ITTI message and copy SDU
-  if (f1ap_req(true, instance)->cell_type==CELL_MACRO_GNB) {
-    message_p = itti_alloc_new_message (TASK_CU_F1, 0, F1AP_INITIAL_UL_RRC_MESSAGE);
-    f1ap_initial_ul_rrc_message_t *ul_rrc = &F1AP_INITIAL_UL_RRC_MESSAGE(message_p);
-    ul_rrc->nr_cellid = nr_cellid; // CU instance
-    ul_rrc->crnti      = rnti;
-    ul_rrc->rrc_container_length = rrccont->value.choice.RRCContainer.size;
-    ul_rrc->rrc_container = malloc(ul_rrc->rrc_container_length);
-    memcpy(ul_rrc->rrc_container, rrccont->value.choice.RRCContainer.buf, ul_rrc->rrc_container_length);
-    AssertFatal(du2cu != NULL, "no masterCellGroup in initial UL RRC message\n");
-    ul_rrc->du2cu_rrc_container_length = du2cu->value.choice.DUtoCURRCContainer.size;
-    ul_rrc->du2cu_rrc_container = malloc(ul_rrc->du2cu_rrc_container_length);
-    memcpy(ul_rrc->du2cu_rrc_container, du2cu->value.choice.DUtoCURRCContainer.buf, ul_rrc->du2cu_rrc_container_length);
-    itti_send_msg_to_task(TASK_RRC_GNB, instance, message_p);
-  } else {
-    message_p = itti_alloc_new_message (TASK_CU_F1, 0, RRC_MAC_CCCH_DATA_IND);
-    memset (RRC_MAC_CCCH_DATA_IND (message_p).sdu, 0, CCCH_SDU_SIZE);
-    ccch_sdu_len = rrccont->value.choice.RRCContainer.size;
-    memcpy(RRC_MAC_CCCH_DATA_IND (message_p).sdu, rrccont->value.choice.RRCContainer.buf,
-           ccch_sdu_len);
-    NR_RRC_MAC_CCCH_DATA_IND (message_p).frame = 0;
-    NR_RRC_MAC_CCCH_DATA_IND (message_p).slot = 0;
-    NR_RRC_MAC_CCCH_DATA_IND (message_p).sdu_size  = ccch_sdu_len;
-    NR_RRC_MAC_CCCH_DATA_IND (message_p).nr_cellid = nr_cellid; // CU instance
-    NR_RRC_MAC_CCCH_DATA_IND (message_p).rnti = rnti;
-    NR_RRC_MAC_CCCH_DATA_IND (message_p).CC_id = CC_id;
-    if (du2cu) {
-      NR_RRC_MAC_CCCH_DATA_IND (message_p).du_to_cu_rrc_container = malloc(sizeof(OCTET_STRING_t));
-      NR_RRC_MAC_CCCH_DATA_IND (message_p).du_to_cu_rrc_container->size = du2cu->value.choice.DUtoCURRCContainer.size;
-      NR_RRC_MAC_CCCH_DATA_IND (message_p).du_to_cu_rrc_container->buf = malloc(du2cu->value.choice.DUtoCURRCContainer.size);
-      memcpy(NR_RRC_MAC_CCCH_DATA_IND (message_p).du_to_cu_rrc_container->buf,
-             du2cu->value.choice.DUtoCURRCContainer.buf,
-             du2cu->value.choice.DUtoCURRCContainer.size);
-    }
-    itti_send_msg_to_task (TASK_RRC_ENB, instance, message_p);
-  }
+  AssertFatal(f1ap_req(true, instance)->cell_type == CELL_MACRO_GNB, "illegal cell type %d\n", f1ap_req(true, instance)->cell_type);
+  message_p = itti_alloc_new_message(TASK_CU_F1, 0, F1AP_INITIAL_UL_RRC_MESSAGE);
+  f1ap_initial_ul_rrc_message_t *ul_rrc = &F1AP_INITIAL_UL_RRC_MESSAGE(message_p);
+  ul_rrc->gNB_DU_ue_id = du_ue_id;
+  ul_rrc->nr_cellid = nr_cellid; // CU instance
+  ul_rrc->crnti = rnti;
+  ul_rrc->rrc_container_length = rrccont->value.choice.RRCContainer.size;
+  ul_rrc->rrc_container = malloc(ul_rrc->rrc_container_length);
+  memcpy(ul_rrc->rrc_container, rrccont->value.choice.RRCContainer.buf, ul_rrc->rrc_container_length);
+  AssertFatal(du2cu != NULL, "no masterCellGroup in initial UL RRC message\n");
+  ul_rrc->du2cu_rrc_container_length = du2cu->value.choice.DUtoCURRCContainer.size;
+  ul_rrc->du2cu_rrc_container = malloc(ul_rrc->du2cu_rrc_container_length);
+  memcpy(ul_rrc->du2cu_rrc_container, du2cu->value.choice.DUtoCURRCContainer.buf, ul_rrc->du2cu_rrc_container_length);
+  itti_send_msg_to_task(TASK_RRC_GNB, instance, message_p);
 
-  //getCxt(true,ITTI_MSG_DESTINATION_ID(message_p))->f1ap_ue[f1ap_uid].du_ue_f1ap_id = du_ue_f1ap_id;
   return 0;
 }
 
@@ -161,26 +132,28 @@ int CU_send_DL_RRC_MESSAGE_TRANSFER(instance_t                instance,
   ie1->id                             = F1AP_ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID;
   ie1->criticality                    = F1AP_Criticality_reject;
   ie1->value.present                  = F1AP_DLRRCMessageTransferIEs__value_PR_GNB_CU_UE_F1AP_ID;
-  ie1->value.choice.GNB_CU_UE_F1AP_ID = f1ap_get_cu_ue_f1ap_id(CUtype, instance, f1ap_dl_rrc->rnti);
-  LOG_D(F1AP, "Setting GNB_CU_UE_F1AP_ID %llu associated with UE RNTI %x (instance %ld)\n",
-        (unsigned long long int)ie1->value.choice.GNB_CU_UE_F1AP_ID, f1ap_dl_rrc->rnti, instance);
+  DevAssert(f1ap_dl_rrc->gNB_CU_ue_id != 0);
+  ie1->value.choice.GNB_CU_UE_F1AP_ID = f1ap_dl_rrc->gNB_CU_ue_id;
+
   /* mandatory */
   /* c2. GNB_DU_UE_F1AP_ID */
   asn1cSequenceAdd(out->protocolIEs.list, F1AP_DLRRCMessageTransferIEs_t, ie2);
   ie2->id                             = F1AP_ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
   ie2->criticality                    = F1AP_Criticality_reject;
   ie2->value.present                  = F1AP_DLRRCMessageTransferIEs__value_PR_GNB_DU_UE_F1AP_ID;
-  ie2->value.choice.GNB_DU_UE_F1AP_ID = f1ap_get_du_ue_f1ap_id(CUtype, instance, f1ap_dl_rrc->rnti);
-  LOG_D(F1AP, "GNB_DU_UE_F1AP_ID %llu associated with UE RNTI %x \n", (unsigned long long int)ie2->value.choice.GNB_DU_UE_F1AP_ID, f1ap_dl_rrc->rnti);
+  DevAssert(f1ap_dl_rrc->gNB_DU_ue_id != 0);
+  ie2->value.choice.GNB_DU_UE_F1AP_ID = f1ap_dl_rrc->gNB_DU_ue_id;
+
   /* optional */
   /* c3. oldgNB_DU_UE_F1AP_ID */
-  /* if (f1ap_dl_rrc->old_gNB_DU_ue_id != 0xFFFFFFFF) {
-     asn1cSequenceAdd(out->protocolIEs.list, F1AP_DLRRCMessageTransferIEs_t, ie3);
-     ie3->id                                = F1AP_ProtocolIE_ID_id_oldgNB_DU_UE_F1AP_ID;
-     ie3->criticality                       = F1AP_Criticality_reject;
-     ie3->value.present                     = F1AP_DLRRCMessageTransferIEs__value_PR_NOTHING;
-     ie3->value.choice.oldgNB_DU_UE_F1AP_ID = f1ap_dl_rrc->old_gNB_DU_ue_id;
-   }*/
+  if (f1ap_dl_rrc->old_gNB_DU_ue_id != NULL) {
+    asn1cSequenceAdd(out->protocolIEs.list, F1AP_DLRRCMessageTransferIEs_t, ie3);
+    ie3->id                                = F1AP_ProtocolIE_ID_id_oldgNB_DU_UE_F1AP_ID;
+    ie3->criticality                       = F1AP_Criticality_reject;
+    ie3->value.present                     = F1AP_DLRRCMessageTransferIEs__value_PR_GNB_DU_UE_F1AP_ID_1;
+    ie3->value.choice.GNB_DU_UE_F1AP_ID_1 = *f1ap_dl_rrc->old_gNB_DU_ue_id;
+  }
+
   /* mandatory */
   /* c4. SRBID */
   asn1cSequenceAdd(out->protocolIEs.list, F1AP_DLRRCMessageTransferIEs_t, ie4);
@@ -267,14 +240,19 @@ int CU_handle_UL_RRC_MESSAGE_TRANSFER(instance_t       instance,
   F1AP_FIND_PROTOCOLIE_BY_ID(F1AP_ULRRCMessageTransferIEs_t, ie, container,
                              F1AP_ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID, true);
   cu_ue_f1ap_id = ie->value.choice.GNB_CU_UE_F1AP_ID;
-  LOG_D(F1AP, "cu_ue_f1ap_id %lu associated with RNTI %x\n",
-        cu_ue_f1ap_id, f1ap_get_rnti_by_cu_id(CUtype, instance, cu_ue_f1ap_id));
   /* GNB_DU_UE_F1AP_ID */
   F1AP_FIND_PROTOCOLIE_BY_ID(F1AP_ULRRCMessageTransferIEs_t, ie, container,
                              F1AP_ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID, true);
   du_ue_f1ap_id = ie->value.choice.GNB_DU_UE_F1AP_ID;
-  LOG_D(F1AP, "du_ue_f1ap_id %lu associated with RNTI %x\n",
-        du_ue_f1ap_id, f1ap_get_rnti_by_cu_id(CUtype, instance, du_ue_f1ap_id));
+  /* the RLC-PDCP does not transport the DU UE ID (yet), so we drop it here.
+   * For the moment, let's hope this won't become relevant; to sleep in peace,
+   * let's put an assert to check that it is the expected DU UE ID. */
+  f1_ue_data_t ue_data = cu_get_f1_ue_data(cu_ue_f1ap_id);
+  AssertFatal(ue_data.secondary_ue == du_ue_f1ap_id,
+              "unexpected DU UE ID %d received, expected it to be %ld\n",
+              ue_data.secondary_ue,
+              du_ue_f1ap_id);
+
   /* mandatory */
   /* SRBID */
   F1AP_FIND_PROTOCOLIE_BY_ID(F1AP_ULRRCMessageTransferIEs_t, ie, container,
@@ -294,7 +272,7 @@ int CU_handle_UL_RRC_MESSAGE_TRANSFER(instance_t       instance,
   protocol_ctxt_t ctxt={0};
   ctxt.instance = instance;
   ctxt.module_id = instance;
-  ctxt.rntiMaybeUEid = f1ap_get_rnti_by_cu_id(CUtype, instance, cu_ue_f1ap_id);
+  ctxt.rntiMaybeUEid = cu_ue_f1ap_id;
   ctxt.enb_flag = 1;
   ctxt.eNB_index = 0;
   mem_block_t *mb = get_free_mem_block(ie->value.choice.RRCContainer.size,__func__);

openair2/F1AP/f1ap_du_rrc_message_transfer.c

@@ -50,6 +50,7 @@
 #include "asn1_msg.h"
 #include "intertask_interface.h"
 #include "LAYER2/NR_MAC_gNB/mac_proto.h"
+#include <openair3/ocp-gtpu/gtp_itf.h>
 
 #include "openair2/LAYER2/NR_MAC_gNB/mac_rrc_dl_handler.h"
 
@@ -60,8 +61,6 @@ int DU_handle_DL_RRC_MESSAGE_TRANSFER(instance_t       instance,
                                       F1AP_F1AP_PDU_t *pdu) {
   F1AP_DLRRCMessageTransfer_t    *container;
   F1AP_DLRRCMessageTransferIEs_t *ie;
-  uint64_t        cu_ue_f1ap_id;
-  uint64_t        du_ue_f1ap_id;
   int             executeDuplication;
   //uint64_t        subscriberProfileIDforRFP;
   //uint64_t        rAT_FrequencySelectionPriority;
@@ -70,26 +69,23 @@ int DU_handle_DL_RRC_MESSAGE_TRANSFER(instance_t       instance,
   /* GNB_CU_UE_F1AP_ID */
   F1AP_FIND_PROTOCOLIE_BY_ID(F1AP_DLRRCMessageTransferIEs_t, ie, container,
                              F1AP_ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID, true);
-  cu_ue_f1ap_id = ie->value.choice.GNB_CU_UE_F1AP_ID;
-  LOG_D(F1AP, "cu_ue_f1ap_id %lu \n", cu_ue_f1ap_id);
+  uint32_t cu_ue_f1ap_id = ie->value.choice.GNB_CU_UE_F1AP_ID;
   /* GNB_DU_UE_F1AP_ID */
   F1AP_FIND_PROTOCOLIE_BY_ID(F1AP_DLRRCMessageTransferIEs_t, ie, container,
                              F1AP_ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID, true);
-  du_ue_f1ap_id = ie->value.choice.GNB_DU_UE_F1AP_ID;
-  LOG_D(F1AP, "du_ue_f1ap_id %lu associated with UE RNTI %x \n",
-        du_ue_f1ap_id,
-        f1ap_get_rnti_by_du_id(DUtype, instance, du_ue_f1ap_id)); // this should be the one transmitted via initial ul rrc message transfer
-
-  if (f1ap_du_add_cu_ue_id(instance,du_ue_f1ap_id, cu_ue_f1ap_id) < 0 ) {
-    LOG_E(F1AP, "Failed to find the F1AP UID \n");
-    //return -1;
-  }
+  uint32_t du_ue_f1ap_id = ie->value.choice.GNB_DU_UE_F1AP_ID;
 
   /* optional */
   /* oldgNB_DU_UE_F1AP_ID */
-  if (0) {
-    F1AP_FIND_PROTOCOLIE_BY_ID(F1AP_DLRRCMessageTransferIEs_t, ie, container,
-                               F1AP_ProtocolIE_ID_id_oldgNB_DU_UE_F1AP_ID, true);
+  uint32_t *old_gNB_DU_ue_id = NULL;
+  uint32_t old_gNB_DU_ue_id_stack = 0;
+  F1AP_FIND_PROTOCOLIE_BY_ID(F1AP_DLRRCMessageTransferIEs_t, ie, container,
+                             F1AP_ProtocolIE_ID_id_oldgNB_DU_UE_F1AP_ID, false);
+  if (ie) {
+    /* strange: it is not named OLD_GNB_DU_UE... */
+    old_gNB_DU_ue_id_stack = ie->value.choice.GNB_DU_UE_F1AP_ID_1;
+    old_gNB_DU_ue_id = &old_gNB_DU_ue_id_stack;
+    gtpv1u_update_ue_id(getCxt(false, instance)->gtpInst, old_gNB_DU_ue_id_stack, du_ue_f1ap_id);
   }
 
   /* mandatory */
@@ -135,34 +131,24 @@ int DU_handle_DL_RRC_MESSAGE_TRANSFER(instance_t       instance,
   }
 
   f1ap_dl_rrc_message_t dl_rrc = {
+    .gNB_CU_ue_id = cu_ue_f1ap_id,
+    .gNB_DU_ue_id = du_ue_f1ap_id,
+    .old_gNB_DU_ue_id = old_gNB_DU_ue_id,
     .rrc_container_length = ie->value.choice.RRCContainer.size,
     .rrc_container = ie->value.choice.RRCContainer.buf,
-    .rnti = f1ap_get_rnti_by_du_id(DUtype, instance, du_ue_f1ap_id),
     .srb_id = srb_id
   };
-  dl_rrc_message(instance, &dl_rrc);
+  dl_rrc_message_transfer(&dl_rrc);
   return 0;
 }
 
 /*  UL RRC Message Transfer */
-int DU_send_INITIAL_UL_RRC_MESSAGE_TRANSFER(instance_t     instanceP,
-    int             CC_idP,
-    int             UE_id,
-    rnti_t          rntiP,
-    const uint8_t   *sduP,
-    sdu_size_t      sdu_lenP,
-    const uint8_t   *sdu2P,
-    sdu_size_t      sdu2_lenP) {
+int DU_send_INITIAL_UL_RRC_MESSAGE_TRANSFER(instance_t instanceP, const f1ap_initial_ul_rrc_message_t *msg)
+{
   F1AP_F1AP_PDU_t                       pdu= {0};
   F1AP_InitialULRRCMessageTransfer_t    *out;
   uint8_t  *buffer=NULL;
   uint32_t  len=0;
-  int f1ap_uid = f1ap_add_ue (DUtype, instanceP, rntiP);
-
-  if (f1ap_uid  < 0 ) {
-    LOG_E(F1AP, "Failed to add UE \n");
-    return -1;
-  }
 
   /* Create */
   /* 0. Message Type */
@@ -178,7 +164,7 @@ int DU_send_INITIAL_UL_RRC_MESSAGE_TRANSFER(instance_t     instanceP,
   ie1->id                             = F1AP_ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
   ie1->criticality                    = F1AP_Criticality_reject;
   ie1->value.present                  = F1AP_InitialULRRCMessageTransferIEs__value_PR_GNB_DU_UE_F1AP_ID;
-  ie1->value.choice.GNB_DU_UE_F1AP_ID = getCxt(DUtype, instanceP)->f1ap_ue[f1ap_uid].du_ue_f1ap_id;
+  ie1->value.choice.GNB_DU_UE_F1AP_ID = msg->gNB_DU_ue_id;
   /* mandatory */
   /* c2. NRCGI */
   asn1cSequenceAdd(out->protocolIEs.list, F1AP_InitialULRRCMessageTransferIEs_t, ie2);
@@ -193,25 +179,25 @@ int DU_send_INITIAL_UL_RRC_MESSAGE_TRANSFER(instance_t     instanceP,
   ie3->id                             = F1AP_ProtocolIE_ID_id_C_RNTI;
   ie3->criticality                    = F1AP_Criticality_reject;
   ie3->value.present                  = F1AP_InitialULRRCMessageTransferIEs__value_PR_C_RNTI;
-  ie3->value.choice.C_RNTI=rntiP;
+  ie3->value.choice.C_RNTI = msg->crnti;
   /* mandatory */
   /* c4. RRCContainer */
   asn1cSequenceAdd(out->protocolIEs.list, F1AP_InitialULRRCMessageTransferIEs_t, ie4);
   ie4->id                            = F1AP_ProtocolIE_ID_id_RRCContainer;
   ie4->criticality                   = F1AP_Criticality_reject;
   ie4->value.present                 = F1AP_InitialULRRCMessageTransferIEs__value_PR_RRCContainer;
-  OCTET_STRING_fromBuf(&ie4->value.choice.RRCContainer, (const char *)sduP, sdu_lenP);
+  OCTET_STRING_fromBuf(&ie4->value.choice.RRCContainer, (const char *)msg->rrc_container, msg->rrc_container_length);
 
   /* optional */
   /* c5. DUtoCURRCContainer */
-  if (sdu2P) {
+  if (msg->du2cu_rrc_container != NULL) {
     asn1cSequenceAdd(out->protocolIEs.list, F1AP_InitialULRRCMessageTransferIEs_t, ie5);
     ie5->id                             = F1AP_ProtocolIE_ID_id_DUtoCURRCContainer;
     ie5->criticality                    = F1AP_Criticality_reject;
     ie5->value.present                  = F1AP_InitialULRRCMessageTransferIEs__value_PR_DUtoCURRCContainer;
     OCTET_STRING_fromBuf(&ie5->value.choice.DUtoCURRCContainer,
-                         (const char *)sdu2P,
-                         sdu2_lenP);
+                         (const char *)msg->du2cu_rrc_container,
+                         msg->du2cu_rrc_container_length);
   }
   /* mandatory */
   /* c6. Transaction ID (integer value) */
@@ -231,16 +217,19 @@ int DU_send_INITIAL_UL_RRC_MESSAGE_TRANSFER(instance_t     instanceP,
   return 0;
 }
 
-
-int DU_send_UL_NR_RRC_MESSAGE_TRANSFER(instance_t instance,
-                                       const f1ap_ul_rrc_message_t *msg) {
-  const rnti_t rnti = msg->rnti;
+int DU_send_UL_NR_RRC_MESSAGE_TRANSFER(instance_t instance, const f1ap_ul_rrc_message_t *msg)
+{
   F1AP_F1AP_PDU_t                pdu= {0};
   F1AP_ULRRCMessageTransfer_t    *out;
   uint8_t *buffer = NULL;
   uint32_t len;
-  LOG_D(F1AP, "[DU %ld] %s: size %d UE RNTI %x in SRB %d\n",
-        instance, __func__, msg->rrc_container_length, rnti, msg->srb_id);
+  LOG_D(F1AP,
+        "[DU %ld] %s: size %d UE RNTI %x in SRB %d\n",
+        instance,
+        __func__,
+        msg->rrc_container_length,
+        msg->gNB_DU_ue_id,
+        msg->srb_id);
   //for (int i = 0;i < msg->rrc_container_length; i++)
   //  printf("%02x ", msg->rrc_container[i]);
   //printf("\n");
@@ -258,14 +247,14 @@ int DU_send_UL_NR_RRC_MESSAGE_TRANSFER(instance_t instance,
   ie1->id                             = F1AP_ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID;
   ie1->criticality                    = F1AP_Criticality_reject;
   ie1->value.present                  = F1AP_ULRRCMessageTransferIEs__value_PR_GNB_CU_UE_F1AP_ID;
-  ie1->value.choice.GNB_CU_UE_F1AP_ID = f1ap_get_cu_ue_f1ap_id(DUtype, instance, rnti);
+  ie1->value.choice.GNB_CU_UE_F1AP_ID = msg->gNB_CU_ue_id;
   /* mandatory */
   /* c2. GNB_DU_UE_F1AP_ID */
   asn1cSequenceAdd(out->protocolIEs.list, F1AP_ULRRCMessageTransferIEs_t, ie2);
   ie2->id                             = F1AP_ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
   ie2->criticality                    = F1AP_Criticality_reject;
   ie2->value.present                  = F1AP_ULRRCMessageTransferIEs__value_PR_GNB_DU_UE_F1AP_ID;
-  ie2->value.choice.GNB_DU_UE_F1AP_ID = f1ap_get_du_ue_f1ap_id(DUtype, instance, rnti);
+  ie2->value.choice.GNB_DU_UE_F1AP_ID = msg->gNB_DU_ue_id;
   /* mandatory */
   /* c3. SRBID */
   asn1cSequenceAdd(out->protocolIEs.list, F1AP_ULRRCMessageTransferIEs_t, ie3);

openair2/F1AP/f1ap_du_rrc_message_transfer.h

@@ -43,13 +43,6 @@ int DU_handle_DL_RRC_MESSAGE_TRANSFER(instance_t       instance,
 
 int DU_send_UL_NR_RRC_MESSAGE_TRANSFER(instance_t instance, const f1ap_ul_rrc_message_t *msg);
 
-int DU_send_INITIAL_UL_RRC_MESSAGE_TRANSFER(instance_t     instanceP,
-    int             CC_idP,
-    int             UE_id,
-    rnti_t          rntiP,
-    const uint8_t   *sduP,
-    sdu_size_t      sdu_lenP,
-    const uint8_t   *sdu2P,
-    sdu_size_t      sdu2_lenP);
+int DU_send_INITIAL_UL_RRC_MESSAGE_TRANSFER(instance_t instanceP, const f1ap_initial_ul_rrc_message_t *msg);
 
 #endif /* F1AP_DU_RRC_MESSAGE_TRANSFER_H_ */

openair2/F1AP/f1ap_du_task.c

@@ -145,7 +145,7 @@ void *F1AP_DU_task(void *arg) {
       case F1AP_INITIAL_UL_RRC_MESSAGE: // from rrc
       {
         f1ap_initial_ul_rrc_message_t *msgRrc = &F1AP_INITIAL_UL_RRC_MESSAGE(msg);
-        DU_send_INITIAL_UL_RRC_MESSAGE_TRANSFER(0, 0, 0, msgRrc->crnti, msgRrc->rrc_container, msgRrc->rrc_container_length, msgRrc->du2cu_rrc_container, msgRrc->du2cu_rrc_container_length);
+        DU_send_INITIAL_UL_RRC_MESSAGE_TRANSFER(myInstance, msgRrc);
       } break;
 
       case F1AP_UL_RRC_MESSAGE: // to rrc

openair2/F1AP/f1ap_du_ue_context_management.c

@@ -77,21 +77,8 @@ int DU_handle_UE_CONTEXT_SETUP_REQUEST(instance_t       instance,
   /* GNB_DU_UE_F1AP_ID */
   F1AP_UEContextSetupRequestIEs_t *ieDU_UE;
   F1AP_FIND_PROTOCOLIE_BY_ID(F1AP_UEContextSetupRequestIEs_t, ieDU_UE, container,
-                             F1AP_ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID, false);
-
-  if (ieDU_UE) {
-    f1ap_ue_context_setup_req->gNB_DU_ue_id =
-      ieDU_UE->value.choice.GNB_DU_UE_F1AP_ID;
-    f1ap_ue_context_setup_req->rnti =
-      f1ap_get_rnti_by_du_id(DUtype, instance, f1ap_ue_context_setup_req->gNB_DU_ue_id);
-  } else {
-    f1ap_ue_context_setup_req->gNB_DU_ue_id = -1;
-    f1ap_ue_context_setup_req->rnti =
-      f1ap_get_rnti_by_cu_id(DUtype, instance, f1ap_ue_context_setup_req->gNB_CU_ue_id);
-  }
-
-  if(f1ap_ue_context_setup_req->rnti<0)
-    LOG_E(F1AP, "Could not retrieve UE rnti based on the CU/DU UE id \n");
+                             F1AP_ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID, true);
+  f1ap_ue_context_setup_req->gNB_DU_ue_id = ieDU_UE->value.choice.GNB_DU_UE_F1AP_ID;
 
   /* SpCell_ID */
   F1AP_UEContextSetupRequestIEs_t *ieNet;
@@ -247,7 +234,7 @@ int DU_send_UE_CONTEXT_SETUP_RESPONSE(instance_t instance, f1ap_ue_context_setup
   ie2->id                             = F1AP_ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
   ie2->criticality                    = F1AP_Criticality_reject;
   ie2->value.present                  = F1AP_UEContextSetupResponseIEs__value_PR_GNB_DU_UE_F1AP_ID;
-  ie2->value.choice.GNB_DU_UE_F1AP_ID = f1ap_get_du_ue_f1ap_id(DUtype, instance, resp->rnti);
+  ie2->value.choice.GNB_DU_UE_F1AP_ID = resp->gNB_DU_ue_id;
 
   /* mandatory */
   /* c3. DUtoCURRCInformation */
@@ -285,7 +272,8 @@ int DU_send_UE_CONTEXT_SETUP_RESPONSE(instance_t instance, f1ap_ue_context_setup
     ie4->criticality                    = F1AP_Criticality_ignore;
     ie4->value.present                  = F1AP_UEContextSetupResponseIEs__value_PR_C_RNTI;
     //C_RNTI_TO_BIT_STRING(rntiP, &ie->value.choice.C_RNTI);
-    ie4->value.choice.C_RNTI=resp->rnti;
+    ie4->value.choice.C_RNTI=0;
+    AssertFatal(false, "not implemented\n");
     LOG_E(F1AP,"RNTI to code!\n");
   }
 
@@ -586,14 +574,14 @@ int DU_send_UE_CONTEXT_RELEASE_REQUEST(instance_t instance,
   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 = f1ap_get_cu_ue_f1ap_id(DUtype, instance, req->rnti);
+  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 = f1ap_get_du_ue_f1ap_id(DUtype, instance, req->rnti);
+  ie2->value.choice.GNB_DU_UE_F1AP_ID = req->gNB_DU_ue_id;
   /* mandatory */
   /* c3. Cause */
   asn1cSequenceAdd(out->protocolIEs.list, F1AP_UEContextReleaseRequestIEs_t, ie3);
@@ -654,13 +642,11 @@ int DU_handle_UE_CONTEXT_RELEASE_COMMAND(instance_t instance, uint32_t assoc_id,
   // GNB_CU_UE_F1AP_ID
   F1AP_FIND_PROTOCOLIE_BY_ID(F1AP_UEContextReleaseCommandIEs_t, ie, container,
                              F1AP_ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID, true);
-  f1ap_ue_context_release_cmd->rnti = f1ap_get_rnti_by_cu_id(DUtype, instance, ie->value.choice.GNB_CU_UE_F1AP_ID);
+  f1ap_ue_context_release_cmd->gNB_CU_ue_id = ie->value.choice.GNB_CU_UE_F1AP_ID;
   // GNB_DU_UE_F1AP_ID
   F1AP_FIND_PROTOCOLIE_BY_ID(F1AP_UEContextReleaseCommandIEs_t, ie, container,
                              F1AP_ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID, true);
-  const rnti_t rnti = f1ap_get_rnti_by_du_id(DUtype, instance,
-                      ie->value.choice.GNB_DU_UE_F1AP_ID);
-  AssertFatal(f1ap_ue_context_release_cmd->rnti == rnti, "RNTI obtained through DU ID (%x) is different from CU ID (%x)\n", rnti, f1ap_ue_context_release_cmd->rnti);
+  f1ap_ue_context_release_cmd->gNB_DU_ue_id = ie->value.choice.GNB_DU_UE_F1AP_ID;
 
   // We don't need the Cause
   // Optional RRC Container: if present, send to UE
@@ -721,14 +707,14 @@ int DU_send_UE_CONTEXT_RELEASE_COMPLETE(instance_t instance, f1ap_ue_context_rel
   ie1->id                             = F1AP_ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID;
   ie1->criticality                    = F1AP_Criticality_reject;
   ie1->value.present                  = F1AP_UEContextReleaseCompleteIEs__value_PR_GNB_CU_UE_F1AP_ID;
-  ie1->value.choice.GNB_CU_UE_F1AP_ID = f1ap_get_cu_ue_f1ap_id(DUtype, instance, complete->rnti);
+  ie1->value.choice.GNB_CU_UE_F1AP_ID = complete->gNB_CU_ue_id;
   /* mandatory */
   /* c2. GNB_DU_UE_F1AP_ID */
   asn1cSequenceAdd(out->protocolIEs.list,F1AP_UEContextReleaseCompleteIEs_t, ie2);
   ie2->id                             = F1AP_ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
   ie2->criticality                    = F1AP_Criticality_reject;
   ie2->value.present                  = F1AP_UEContextReleaseCompleteIEs__value_PR_GNB_DU_UE_F1AP_ID;
-  ie2->value.choice.GNB_DU_UE_F1AP_ID = f1ap_get_du_ue_f1ap_id(DUtype, instance, complete->rnti);
+  ie2->value.choice.GNB_DU_UE_F1AP_ID = complete->gNB_DU_ue_id;
   /* optional -> currently not used */
   /* c3. CriticalityDiagnostics */
   //if (0) {
@@ -790,7 +776,6 @@ int DU_send_UE_CONTEXT_RELEASE_COMPLETE(instance_t instance, f1ap_ue_context_rel
                                buffer,
                                len,
                                getCxt(false, instance)->default_sctp_stream_id);
-  f1ap_remove_ue(DUtype, instance, complete->rnti);
   return 0;
 }
 
@@ -825,12 +810,6 @@ int DU_handle_UE_CONTEXT_MODIFICATION_REQUEST(instance_t instance, uint32_t asso
   F1AP_FIND_PROTOCOLIE_BY_ID(F1AP_UEContextModificationRequestIEs_t, ieDU_UE, container,
       F1AP_ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID, true);
   f1ap_ue_context_modification_req->gNB_DU_ue_id = ieDU_UE->value.choice.GNB_DU_UE_F1AP_ID;
-  f1ap_ue_context_modification_req->rnti = f1ap_get_rnti_by_du_id(DUtype, instance, f1ap_ue_context_modification_req->gNB_DU_ue_id);
-
-  if(f1ap_ue_context_modification_req->rnti<0)
-      LOG_E(F1AP, "Could not retrieve UE rnti based on the DU UE id \n");
-  else
-      LOG_D(F1AP, "Retrieved rnti is: %d \n", f1ap_ue_context_modification_req->rnti);
 
   /* SRB */
   F1AP_UEContextModificationRequestIEs_t *ieSrb;
@@ -944,7 +923,7 @@ int DU_handle_UE_CONTEXT_MODIFICATION_REQUEST(instance_t instance, uint32_t asso
           ieRRC->value.choice.RRCContainer.buf, ieRRC->value.choice.RRCContainer.size);
       protocol_ctxt_t ctxt;
       // decode RRC Container and act on the message type
-      ctxt.rntiMaybeUEid = f1ap_ue_context_modification_req->rnti;
+      ctxt.rntiMaybeUEid = f1ap_ue_context_modification_req->gNB_DU_ue_id;
       ctxt.instance = instance;
       ctxt.module_id  = instance;
       ctxt.enb_flag  = 1;
@@ -991,7 +970,7 @@ int DU_send_UE_CONTEXT_MODIFICATION_RESPONSE(instance_t instance, f1ap_ue_contex
   ie2->id                             = F1AP_ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
   ie2->criticality                    = F1AP_Criticality_reject;
   ie2->value.present                  = F1AP_UEContextModificationResponseIEs__value_PR_GNB_DU_UE_F1AP_ID;
-  ie2->value.choice.GNB_DU_UE_F1AP_ID = f1ap_get_du_ue_f1ap_id(DUtype, instance, resp->rnti);
+  ie2->value.choice.GNB_DU_UE_F1AP_ID = resp->gNB_DU_ue_id;
 
   /* optional */
   /* c3. ResourceCoordinationTransferContainer */
@@ -1057,7 +1036,7 @@ int DU_send_UE_CONTEXT_MODIFICATION_RESPONSE(instance_t instance, f1ap_ue_contex
         memcpy(tl_addr.buffer, &drb->up_ul_tnl[0].tl_address, sizeof(drb->up_ul_tnl[0].tl_address));
         tl_addr.length = sizeof(drb->up_ul_tnl[0].tl_address) * 8;
         drb->up_dl_tnl[j].teid = newGtpuCreateTunnel(getCxt(false, instance)->gtpInst,
-                                                     resp->rnti,
+                                                     resp->gNB_DU_ue_id,
                                                      drb->drb_id,
                                                      drb->drb_id,
                                                      drb->up_ul_tnl[j].teid,

openair2/F1AP/f1ap_ids.c

+/*
+ * Licensed to the OpenAirInterface (OAI) Software Alliance under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The OpenAirInterface Software Alliance licenses this file to You under
+ * the OAI Public License, Version 1.1  (the "License"); you may not use this file
+ * except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.openairinterface.org/?page_id=698
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *-------------------------------------------------------------------------------
+ * For more information about the OpenAirInterface (OAI) Software Alliance:
+ *      contact@openairinterface.org
+ */
+
+/* "standalone" module to store a "secondary" UE ID for each UE in DU/CU.
+ * Separate from the rest of F1, as it is also relevant for monolithic. */
+
+#include "f1ap_ids.h"
+
+#include <pthread.h>
+#include "common/utils/hashtable/hashtable.h"
+#include "common/utils/assertions.h"
+
+
+/* we have separate versions for CU and DU, as both CU&DU might coexist in the
+ * same process */
+static hash_table_t *cu2du_ue_mapping;
+static pthread_mutex_t cu2du_mutex = PTHREAD_MUTEX_INITIALIZER;
+
+void cu_init_f1_ue_data(void)
+{
+  pthread_mutex_lock(&cu2du_mutex);
+  DevAssert(cu2du_ue_mapping == NULL);
+  cu2du_ue_mapping = hashtable_create(1319, NULL, free); // 1319 is prime, default hash func (unit), free()
+  DevAssert(cu2du_ue_mapping != NULL);
+  pthread_mutex_unlock(&cu2du_mutex);
+}
+
+bool cu_add_f1_ue_data(uint32_t ue_id, const f1_ue_data_t *data)
+{
+  pthread_mutex_lock(&cu2du_mutex);
+  DevAssert(cu2du_ue_mapping != NULL);
+  uint64_t key = ue_id;
+  if (hashtable_is_key_exists(cu2du_ue_mapping, key) == HASH_TABLE_OK) {
+    pthread_mutex_unlock(&cu2du_mutex);
+    return false;
+  }
+  f1_ue_data_t *idata = malloc(sizeof(*idata));
+  AssertFatal(idata != NULL, "cannot allocate memory\n");
+  *idata = *data;
+  hashtable_rc_t ret = hashtable_insert(cu2du_ue_mapping, key, idata);
+  pthread_mutex_unlock(&cu2du_mutex);
+  return ret == HASH_TABLE_OK;
+}
+
+bool cu_exists_f1_ue_data(uint32_t ue_id)
+{
+  pthread_mutex_lock(&cu2du_mutex);
+  DevAssert(cu2du_ue_mapping != NULL);
+  uint64_t key = ue_id;
+  hashtable_rc_t ret = hashtable_is_key_exists(cu2du_ue_mapping, key);
+  pthread_mutex_unlock(&cu2du_mutex);
+  return ret == HASH_TABLE_OK;
+}
+
+f1_ue_data_t cu_get_f1_ue_data(uint32_t ue_id)
+{
+  pthread_mutex_lock(&cu2du_mutex);
+  DevAssert(cu2du_ue_mapping != NULL);
+  uint64_t key = ue_id;
+  void *data = NULL;
+  hashtable_rc_t ret = hashtable_get(cu2du_ue_mapping, key, &data);
+  AssertFatal(ret == HASH_TABLE_OK && data != NULL, "element for ue_id %d not found\n", ue_id);
+  f1_ue_data_t ued = *(f1_ue_data_t *)data;
+  pthread_mutex_unlock(&cu2du_mutex);
+  return ued;
+}
+
+bool cu_remove_f1_ue_data(uint32_t ue_id)
+{
+  pthread_mutex_lock(&cu2du_mutex);
+  DevAssert(cu2du_ue_mapping != NULL);
+  uint64_t key = ue_id;
+  hashtable_rc_t ret = hashtable_remove(cu2du_ue_mapping, key);
+  pthread_mutex_unlock(&cu2du_mutex);
+  return ret == HASH_TABLE_OK;
+}
+
+/* DU version below */
+static hash_table_t *du2cu_ue_mapping;
+static pthread_mutex_t du2cu_mutex = PTHREAD_MUTEX_INITIALIZER;
+
+void du_init_f1_ue_data(void)
+{
+  pthread_mutex_lock(&du2cu_mutex);
+  DevAssert(du2cu_ue_mapping == NULL);
+  du2cu_ue_mapping = hashtable_create(1319, NULL, free); // 1319 is prime, default hash func (unit), free()
+  DevAssert(du2cu_ue_mapping != NULL);
+  pthread_mutex_unlock(&du2cu_mutex);
+}
+
+bool du_add_f1_ue_data(uint32_t ue_id, const f1_ue_data_t *data)
+{
+  pthread_mutex_lock(&du2cu_mutex);
+  DevAssert(du2cu_ue_mapping != NULL);
+  uint64_t key = ue_id;
+  if (hashtable_is_key_exists(du2cu_ue_mapping, key) == HASH_TABLE_OK) {
+    pthread_mutex_unlock(&du2cu_mutex);
+    return false;
+  }
+  f1_ue_data_t *idata = malloc(sizeof(*idata));
+  AssertFatal(idata != NULL, "cannot allocate memory\n");
+  *idata = *data;
+  hashtable_rc_t ret = hashtable_insert(du2cu_ue_mapping, key, idata);
+  pthread_mutex_unlock(&du2cu_mutex);
+  return ret == HASH_TABLE_OK;
+}
+
+bool du_exists_f1_ue_data(uint32_t ue_id)
+{
+  pthread_mutex_lock(&du2cu_mutex);
+  DevAssert(du2cu_ue_mapping != NULL);
+  uint64_t key = ue_id;
+  hashtable_rc_t ret = hashtable_is_key_exists(du2cu_ue_mapping, key);
+  pthread_mutex_unlock(&du2cu_mutex);
+  return ret == HASH_TABLE_OK;
+}
+
+f1_ue_data_t du_get_f1_ue_data(uint32_t ue_id)
+{
+  pthread_mutex_lock(&du2cu_mutex);
+  DevAssert(du2cu_ue_mapping != NULL);
+  uint64_t key = ue_id;
+  void *data = NULL;
+  hashtable_rc_t ret = hashtable_get(du2cu_ue_mapping, key, &data);
+  AssertFatal(ret == HASH_TABLE_OK && data != NULL, "element for ue_id %d not found\n", ue_id);
+  f1_ue_data_t ued = *(f1_ue_data_t *)data;
+  pthread_mutex_unlock(&du2cu_mutex);
+  return ued;
+}
+
+bool du_remove_f1_ue_data(uint32_t ue_id)
+{
+  pthread_mutex_lock(&du2cu_mutex);
+  DevAssert(du2cu_ue_mapping != NULL);
+  uint64_t key = ue_id;
+  hashtable_rc_t ret = hashtable_remove(du2cu_ue_mapping, key);
+  pthread_mutex_unlock(&du2cu_mutex);
+  return ret == HASH_TABLE_OK;
+}

openair2/F1AP/f1ap_ids.h

+/*
+ * Licensed to the OpenAirInterface (OAI) Software Alliance under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The OpenAirInterface Software Alliance licenses this file to You under
+ * the OAI Public License, Version 1.1  (the "License"); you may not use this file
+ * except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.openairinterface.org/?page_id=698
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *-------------------------------------------------------------------------------
+ * For more information about the OpenAirInterface (OAI) Software Alliance:
+ *      contact@openairinterface.org
+ */
+
+/* "standalone" module to store a "secondary" UE ID for each UE in DU/CU.
+ * Separate from the rest of F1, as it is also relevant for monolithic. */
+
+#ifndef F1AP_IDS_H_
+#define F1AP_IDS_H_
+
+#include <stdbool.h>
+#include <stdint.h>
+
+typedef struct f1_ue_data_t {
+  uint32_t secondary_ue;
+  /* can be extended with F1-specific data also relevant for monolithic */
+} f1_ue_data_t;
+
+void cu_init_f1_ue_data(void);
+bool cu_add_f1_ue_data(uint32_t ue_id, const f1_ue_data_t *data);
+bool cu_exists_f1_ue_data(uint32_t ue_id);
+f1_ue_data_t cu_get_f1_ue_data(uint32_t ue_id);
+bool cu_remove_f1_ue_data(uint32_t ue_id);
+
+void du_init_f1_ue_data(void);
+bool du_add_f1_ue_data(uint32_t ue_id, const f1_ue_data_t *data);
+bool du_exists_f1_ue_data(uint32_t ue_id);
+f1_ue_data_t du_get_f1_ue_data(uint32_t ue_id);
+bool du_remove_f1_ue_data(uint32_t ue_id);
+
+#endif /* F1AP_IDS_H_ */

openair2/F1AP/f1ap_ids_test.c

+/*
+ * Licensed to the OpenAirInterface (OAI) Software Alliance under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The OpenAirInterface Software Alliance licenses this file to You under
+ * the OAI Public License, Version 1.1  (the "License"); you may not use this file
+ * except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.openairinterface.org/?page_id=698
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *-------------------------------------------------------------------------------
+ * For more information about the OpenAirInterface (OAI) Software Alliance:
+ *      contact@openairinterface.org
+ */
+
+#include <stdio.h>
+#include <stdint.h>
+#include <stddef.h>
+#include "common/utils/assertions.h"
+#include "f1ap_ids.h"
+
+int main()
+{
+  du_init_f1_ue_data();
+  int rnti = 13;
+  f1_ue_data_t data = {.secondary_ue = 1};
+  bool ret = du_add_f1_ue_data(rnti, &data);
+  DevAssert(ret);
+  ret = du_add_f1_ue_data(rnti, &data);
+  DevAssert(!ret);
+  bool exists = du_exists_f1_ue_data(rnti);
+  DevAssert(exists);
+  f1_ue_data_t rdata = du_get_f1_ue_data(rnti);
+  DevAssert(rdata.secondary_ue == data.secondary_ue);
+  return 0;
+}

openair2/LAYER2/NR_MAC_UE/main_ue_nr.c

@@ -79,7 +79,7 @@ NR_UE_MAC_INST_t * nr_l2_init_ue(NR_UE_RRC_INST_t* rrc_inst) {
 
         // set up PDCP, RLC, MAC
         nr_pdcp_layer_init();
-        nr_pdcp_add_drbs(ENB_FLAG_NO, nr_ue_mac_inst->crnti, 0, rbconfig->drb_ToAddModList, 0, NULL, NULL, &rlc_bearer_list);
+        nr_pdcp_add_drbs(ENB_FLAG_NO, nr_ue_mac_inst->crnti, rbconfig->drb_ToAddModList, 0, NULL, NULL, &rlc_bearer_list);
         nr_rlc_add_drb(nr_ue_mac_inst->crnti, rbconfig->drb_ToAddModList->list.array[0]->drb_Identity, rlc_rbconfig);
         nr_ue_mac_inst->logicalChannelBearer_exist[0] = true;
 

openair2/LAYER2/NR_MAC_gNB/gNB_scheduler_RA.c

@@ -2083,7 +2083,7 @@ static void nr_check_Msg4_Ack(module_id_t module_id, int CC_id, frame_t frame, s
 
         // Pause scheduling according to:
         // 3GPP TS 38.331 Section 12 Table 12.1-1: UE performance requirements for RRC procedures for UEs
-        const NR_ServingCellConfig_t *servingCellConfig = UE->CellGroup ? UE->CellGroup->spCellConfig->spCellConfigDedicated : NULL;
+        const NR_ServingCellConfig_t *servingCellConfig = UE->CellGroup && UE->CellGroup->spCellConfig ? UE->CellGroup->spCellConfig->spCellConfigDedicated : NULL;
         uint32_t delay_ms = servingCellConfig && servingCellConfig->downlinkBWP_ToAddModList ?
             NR_RRC_SETUP_DELAY_MS + NR_RRC_BWP_SWITCHING_DELAY_MS : NR_RRC_SETUP_DELAY_MS;
 

openair2/LAYER2/NR_MAC_gNB/gNB_scheduler_primitives.c

@@ -47,6 +47,7 @@
 #include "RRC/NR/MESSAGES/asn1_msg.h"
 
 #include "intertask_interface.h"
+#include "openair2/F1AP/f1ap_ids.h"
 
 #include "T.h"
 
@@ -1992,22 +1993,7 @@ void delete_nr_ue_data(NR_UE_info_t *UE, NR_COMMON_channels_t *ccPtr, uid_alloca
   destroy_nr_list(&sched_ctrl->retrans_ul_harq);
   uid_linear_allocator_free(uia, UE->uid);
   LOG_I(NR_MAC, "Remove NR rnti 0x%04x\n", UE->rnti);
-  const rnti_t rnti = UE->rnti;
   free(UE);
-
-  /* clear RA process(es?) associated to the UE */
-  for (int cc_id = 0; cc_id < NFAPI_CC_MAX; cc_id++) {
-    for (int i = 0; i < NR_NB_RA_PROC_MAX; i++) {
-      NR_COMMON_channels_t *cc = &ccPtr[cc_id];
-      if (cc->ra[i].rnti == rnti) {
-        LOG_D(NR_MAC, "free RA process %d for rnti %04x\n", i, rnti);
-        /* is it enough? */
-        cc->ra[i].cfra = false;
-        cc->ra[i].rnti = 0;
-        cc->ra[i].crnti = 0;
-      }
-    }
-  }
 }
 
 
@@ -2922,6 +2908,7 @@ void send_initial_ul_rrc_message(gNB_MAC_INST *mac, int rnti, const uint8_t *sdu
 
   const f1ap_initial_ul_rrc_message_t ul_rrc_msg = {
     /* TODO: add mcc, mnc, cell_id, ..., is not available at MAC yet */
+    .gNB_DU_ue_id = rnti,
     .crnti = rnti,
     .rrc_container = (uint8_t *) sdu,
     .rrc_container_length = sdu_len,
@@ -2997,8 +2984,10 @@ void nr_mac_check_ul_failure(const gNB_MAC_INST *nrmac, int rnti, NR_UE_sched_ct
   /* to trigger only once: trigger when ul_failure_timer == 1, but timer will
    * stop at 0 and we wait for a UE release command from upper layers */
   if (sched_ctrl->ul_failure_timer == 1) {
+    f1_ue_data_t ue_data = du_get_f1_ue_data(rnti);
     f1ap_ue_context_release_complete_t complete = {
-      .rnti = rnti,
+      .gNB_CU_ue_id = ue_data.secondary_ue,
+      .gNB_DU_ue_id = rnti,
       .cause = F1AP_CAUSE_RADIO_NETWORK,
       .cause_value = 12, // F1AP_CauseRadioNetwork_rl_failure_others
     };

openair2/LAYER2/NR_MAC_gNB/mac_rrc_dl_handler.h

@@ -29,6 +29,6 @@ void ue_context_setup_request(const f1ap_ue_context_setup_t *req);
 void ue_context_modification_request(const f1ap_ue_context_modif_req_t *req);
 void ue_context_release_command(const f1ap_ue_context_release_cmd_t *cmd);
 
-int dl_rrc_message(module_id_t module_id, const f1ap_dl_rrc_message_t *dl_rrc);
+void dl_rrc_message_transfer(const f1ap_dl_rrc_message_t *dl_rrc);
 
 #endif /* MAC_RRC_DL_HANDLER_H */

openair2/LAYER2/NR_MAC_gNB/mac_rrc_ul_direct.c

@@ -64,7 +64,6 @@ static void ue_context_modification_response_direct(const f1ap_ue_context_modif_
 
   f1ap_msg->gNB_CU_ue_id = resp->gNB_CU_ue_id;
   f1ap_msg->gNB_DU_ue_id = resp->gNB_DU_ue_id;
-  f1ap_msg->rnti = resp->rnti;
   f1ap_msg->mcc = resp->mcc;
   f1ap_msg->mnc = resp->mnc;
   f1ap_msg->mnc_digit_length = resp->mnc_digit_length;

openair2/LAYER2/NR_MAC_gNB/mac_rrc_ul_f1ap.c

@@ -106,7 +106,7 @@ static void ue_context_release_request_f1ap(const f1ap_ue_context_release_req_t*
 
 static void ue_context_release_complete_f1ap(const f1ap_ue_context_release_complete_t *complete)
 {
-  newGtpuDeleteAllTunnels(0, complete->rnti);
+  newGtpuDeleteAllTunnels(0, complete->gNB_DU_ue_id);
 
   MessageDef *msg = itti_alloc_new_message(TASK_MAC_GNB, 0, F1AP_UE_CONTEXT_RELEASE_COMPLETE);
   f1ap_ue_context_release_complete_t *f1ap_msg = &F1AP_UE_CONTEXT_RELEASE_COMPLETE(msg);

openair2/LAYER2/NR_MAC_gNB/main.c

@@ -40,6 +40,7 @@
 #include "nr_rlc/nr_rlc_oai_api.h"
 #include "RRC/NR/MESSAGES/asn1_msg.h"
 //#include "RRC/L2_INTERFACE/openair_rrc_L2_interface.h"
+#include "openair2/F1AP/f1ap_ids.h"
 
 #include "common/ran_context.h"
 #include "executables/softmodem-common.h"
@@ -283,7 +284,7 @@ void mac_top_init_gNB(ngran_node_t node_type)
        * will output the packets at a local interface, which is in line with
        * the noS1 mode.  Hence, below, we simply hardcode ENB_FLAG_NO */
       // setup PDCP, RLC
-      nr_pdcp_add_drbs(ENB_FLAG_NO, 0x1234, 0, rbconfig->drb_ToAddModList, 0, NULL, NULL, &rlc_bearer_list);
+      nr_pdcp_add_drbs(ENB_FLAG_NO, 0x1234, rbconfig->drb_ToAddModList, 0, NULL, NULL, &rlc_bearer_list);
       nr_rlc_add_drb(0x1234, rbconfig->drb_ToAddModList->list.array[0]->drb_Identity, rlc_rbconfig);
 
       // free memory
@@ -301,5 +302,7 @@ void mac_top_init_gNB(ngran_node_t node_type)
     memset(&nrmac->UE_info, 0, sizeof(nrmac->UE_info));
   }
 
+  du_init_f1_ue_data();
+
   srand48(0);
 }

openair2/LAYER2/NR_MAC_gNB/nr_mac_gNB.h

@@ -46,19 +46,19 @@
 #define NR_SCHED_LOCK(lock)                                        \
   do {                                                             \
     int rc = pthread_mutex_lock(lock);                             \
-    AssertFatal(rc == 0, "error while locking scheduler mutex\n"); \
+    AssertFatal(rc == 0, "error while locking scheduler mutex, pthread_mutex_lock() returned %d\n", rc); \
   } while (0)
 
 #define NR_SCHED_UNLOCK(lock)                                      \
   do {                                                             \
     int rc = pthread_mutex_unlock(lock);                           \
-    AssertFatal(rc == 0, "error while locking scheduler mutex\n"); \
+    AssertFatal(rc == 0, "error while locking scheduler mutex, pthread_mutex_unlock() returned %d\n", rc); \
   } while (0)
 
 #define NR_SCHED_ENSURE_LOCKED(lock)\
   do {\
     int rc = pthread_mutex_trylock(lock); \
-    AssertFatal(rc == EBUSY, "this function should be called with the scheduler mutex locked\n");\
+    AssertFatal(rc == EBUSY, "this function should be called with the scheduler mutex locked, pthread_mutex_trylock() returned %d\n", rc);\
   } while (0)
 
 /* Commmon */
@@ -675,7 +675,11 @@ typedef struct {
   NR_UE_DL_BWP_t current_DL_BWP;
   NR_UE_UL_BWP_t current_UL_BWP;
   NR_mac_stats_t mac_stats;
+  /// currently active CellGroupConfig
   NR_CellGroupConfig_t *CellGroup;
+  /// CellGroupConfig that is to be activated after the next reconfiguration
+  NR_CellGroupConfig_t *reconfigCellGroup;
+  bool expect_reconfiguration;
   char cg_buf[32768]; /* arbitrary size */
   asn_enc_rval_t enc_rval;
   // UE selected beam index

openair2/LAYER2/nr_pdcp/nr_pdcp_e1_api.c

@@ -32,7 +32,7 @@ void e1_add_drb(int is_gnb,
                 unsigned char *ciphering_key,
                 unsigned char *integrity_key)
 {
-  add_drb_am(is_gnb, ue_id, 0, s, ciphering_algorithm, integrity_algorithm,
+  add_drb_am(is_gnb, ue_id, s, ciphering_algorithm, integrity_algorithm,
              ciphering_key, integrity_key);
   LOG_I(PDCP, "%s:%s:%d: added DRB for UE ID %ld\n", __FILE__, __FUNCTION__, __LINE__, ue_id);
 }

openair2/LAYER2/nr_pdcp/nr_pdcp_e1_api.h

@@ -45,7 +45,7 @@ void nr_pdcp_e1_add_drbs(eNB_flag_t enb_flag,
                          uint8_t        *const kUPenc,
                          uint8_t        *const kUPint);
 
-void add_drb_am(int is_gnb, ue_id_t rntiMaybeUEid, ue_id_t reestablish_ue_id, struct NR_DRB_ToAddMod *s,
+void add_drb_am(int is_gnb, ue_id_t rntiMaybeUEid, struct NR_DRB_ToAddMod *s,
                 int ciphering_algorithm,
                 int integrity_algorithm,
                 unsigned char *ciphering_key,

openair2/LAYER2/nr_pdcp/nr_pdcp_oai_api.h

@@ -48,7 +48,6 @@ bool pdcp_data_ind(const protocol_ctxt_t *const  ctxt_pP,
 
 void nr_pdcp_add_drbs(eNB_flag_t enb_flag,
                       ue_id_t rntiMaybeUEid,
-                      ue_id_t reestablish_ue_id,
                       NR_DRB_ToAddModList_t *const drb2add_list,
                       const uint8_t security_modeP,
                       uint8_t *const kUPenc,
@@ -58,6 +57,7 @@ void nr_pdcp_add_drbs(eNB_flag_t enb_flag,
 void nr_DRB_preconfiguration(ue_id_t crntiMaybeUEid);
 
 bool nr_pdcp_remove_UE(ue_id_t ue_id);
+void nr_pdcp_reestablishment(ue_id_t ue_id);
 
 void nr_pdcp_config_set_security(ue_id_t ue_id,
                                  const rb_id_t rb_id,
@@ -80,10 +80,7 @@ bool cu_f1u_data_req(protocol_ctxt_t  *ctxt_pP,
 typedef void (*deliver_pdu)(void *data, ue_id_t ue_id, int srb_id,
                             char *buf, int size, int sdu_id);
 /* default implementation of deliver_pdu */
-void deliver_pdu_srb_rlc(void *data, ue_id_t ue_id, int srb_id, char *buf,
-                         int size, int sdu_id);
-void deliver_pdu_srb_f1(void *data, ue_id_t ue_id, int srb_id, char *buf,
-                        int size, int sdu_id);
+void deliver_pdu_srb_rlc(void *data, ue_id_t ue_id, int srb_id, char *buf, int size, int sdu_id);
 bool nr_pdcp_data_req_srb(ue_id_t ue_id,
                           const rb_id_t rb_id,
                           const mui_t muiP,

openair2/LAYER2/nr_rlc/nr_rlc_oai_api.c

@@ -39,6 +39,7 @@
 #include "NR_UL-CCCH-Message.h"
 
 #include "openair2/F1AP/f1ap_du_rrc_message_transfer.h"
+#include "openair2/F1AP/f1ap_ids.h"
 
 extern RAN_CONTEXT_t RC;
 
@@ -425,11 +426,18 @@ rb_found:
   ctx.eNB_index = 0;
   ctx.brOption = 0;
 
+  is_enb = nr_rlc_manager_get_enb_flag(nr_rlc_ue_manager);
+
   /* used fields? */
   ctx.module_id = 0;
+  /* CU (PDCP, RRC, SDAP) use a different ID than RNTI, so below set the CU UE
+   * ID if in gNB, else use RNTI normally */
   ctx.rntiMaybeUEid = ue->rnti;
+  if (is_enb) {
+    f1_ue_data_t ue_data = du_get_f1_ue_data(ue->rnti);
+    ctx.rntiMaybeUEid = ue_data.secondary_ue;
+  }
 
-  is_enb = nr_rlc_manager_get_enb_flag(nr_rlc_ue_manager);
   ctx.enb_flag = is_enb;
 
   if (is_enb) {
@@ -453,7 +461,8 @@ rb_found:
 	msg = itti_alloc_new_message(TASK_RLC_ENB, 0, F1AP_UL_RRC_MESSAGE);
 	uint8_t *message_buffer = itti_malloc (TASK_RLC_ENB, TASK_DU_F1, size);
 	memcpy (message_buffer, buf, size);
-	F1AP_UL_RRC_MESSAGE(msg).rnti = ue->rnti;
+        F1AP_UL_RRC_MESSAGE(msg).gNB_CU_ue_id = ctx.rntiMaybeUEid;
+	F1AP_UL_RRC_MESSAGE(msg).gNB_DU_ue_id = ue->rnti;
 	F1AP_UL_RRC_MESSAGE(msg).srb_id = rb_id;
 	F1AP_UL_RRC_MESSAGE(msg).rrc_container = message_buffer;
 	F1AP_UL_RRC_MESSAGE(msg).rrc_container_length = size;
@@ -467,7 +476,7 @@ rb_found:
 	memcpy(req->buffer,buf,size);
 	req->length=size;
 	req->offset=0;
-	req->ue_id=ue->rnti;
+	req->ue_id=ue->rnti; // use RNTI here, which GTP will use to look up TEID
 	req->bearer_id=rb_id;
 	LOG_D(RLC, "Received uplink user-plane traffic at RLC-DU to be sent to the CU, size %d \n", size);
 	extern instance_t DUuniqInstance;
@@ -477,6 +486,7 @@ rb_found:
     }
   }
 
+  /* UE or monolithic gNB */
   memblock = get_free_mem_block(size, __func__);
   if (memblock == NULL) {
     LOG_E(RLC, "%s:%d:%s: ERROR: get_free_mem_block failed\n", __FILE__, __LINE__, __FUNCTION__);
@@ -1000,6 +1010,45 @@ rlc_op_status_t rrc_rlc_remove_ue (const protocol_ctxt_t* const x)
   return RLC_OP_STATUS_OK;
 }
 
+bool nr_rlc_update_rnti(int from_rnti, int to_rnti)
+{
+  nr_rlc_manager_lock(nr_rlc_ue_manager);
+  nr_rlc_ue_t *ue = nr_rlc_manager_get_ue(nr_rlc_ue_manager, from_rnti);
+  if (ue == NULL) {
+    nr_rlc_manager_unlock(nr_rlc_ue_manager);
+    LOG_E(RLC, "Cannot find RLC entity for UE %04x\n", from_rnti);
+    return false;
+  }
+  ue->rnti = to_rnti;
+  LOG_I(RLC, "Update old UE RNTI %04x context to RNTI %04x\n", from_rnti, to_rnti);
+  for (int i = 0; i < sizeof(ue->srb) / sizeof(ue->srb[0]); ++i)
+    if (ue->srb[i])
+      ue->srb[i]->reestablishment(ue->srb[i]);
+  for (int i = 0; i < sizeof(ue->drb) / sizeof(ue->drb[0]); ++i)
+    if (ue->drb[i])
+      ue->drb[i]->reestablishment(ue->drb[i]);
+  nr_rlc_manager_unlock(nr_rlc_ue_manager);
+  return true;
+}
+
+/* This function is for testing purposes. At least on a COTS UE, it will
+ * trigger a reestablishment. */
+void nr_rlc_test_trigger_reestablishment(int rnti)
+{
+  nr_rlc_manager_lock(nr_rlc_ue_manager);
+  nr_rlc_ue_t *ue = nr_rlc_manager_get_ue(nr_rlc_ue_manager, rnti);
+  if (ue == NULL) {
+    nr_rlc_manager_unlock(nr_rlc_ue_manager);
+    LOG_E(RLC, "Cannot find RLC entity for UE %04x\n", rnti);
+    return;
+  }
+  /* we simply assume the SRB exists, because the scheduler creates it as soon
+   * as the UE context is created. */
+  nr_rlc_entity_t *ent = ue->srb[0];
+  ent->reestablishment(ent);
+  nr_rlc_manager_unlock(nr_rlc_ue_manager);
+}
+
 void nr_rlc_tick(int frame, int subframe)
 {
   if (frame != nr_rlc_current_time_last_frame ||

openair2/LAYER2/nr_rlc/nr_rlc_oai_api.h

@@ -43,6 +43,10 @@ void nr_rlc_add_srb(int rnti, int srb_id, const NR_RLC_BearerConfig_t *rlc_Beare
 void nr_rlc_add_drb(int rnti, int drb_id, const NR_RLC_BearerConfig_t *rlc_BearerConfig);
 
 void nr_rlc_remove_ue(int rnti);
+bool nr_rlc_update_rnti(int from_rnti, int to_rnti);
+
+/* test function for CI to trigger reestablishments */
+void nr_rlc_test_trigger_reestablishment(int rnti);
 
 int nr_rlc_get_available_tx_space(
   const rnti_t            rntiP,

openair2/RRC/NR/L2_nr_interface.c

@@ -52,16 +52,6 @@
 
 extern RAN_CONTEXT_t RC;
 
-void nr_rrc_mac_remove_ue(rnti_t rntiMaybeUEid)
-{
-  nr_rlc_remove_ue(rntiMaybeUEid);
-
-  gNB_MAC_INST *nrmac = RC.nrmac[0];
-  NR_SCHED_LOCK(&nrmac->sched_lock);
-  mac_remove_nr_ue(nrmac, rntiMaybeUEid);
-  NR_SCHED_UNLOCK(&nrmac->sched_lock);
-}
-
 void nr_rrc_mac_update_cellgroup(rnti_t rntiMaybeUEid, NR_CellGroupConfig_t *cgc)
 {
   gNB_MAC_INST *nrmac = RC.nrmac[0];

openair2/RRC/NR/MESSAGES/asn1_msg.c

@@ -783,7 +783,7 @@ int16_t do_RRCReconfiguration(
     }
 
     if(cellGroupConfig!=NULL){
-      update_cellGroupConfig(cellGroupConfig, ue_context_pP->ue_context.gNB_ue_ngap_id, ue_context_pP ? ue_context_pP->ue_context.UE_Capability_nr : NULL, configuration);
+      update_cellGroupConfig(cellGroupConfig, ue_context_pP->ue_context.rrc_ue_id, ue_context_pP ? ue_context_pP->ue_context.UE_Capability_nr : NULL, configuration);
 
       enc_rval = uper_encode_to_buffer(&asn_DEF_NR_CellGroupConfig,
                                        NULL,
@@ -1100,8 +1100,7 @@ uint8_t do_RRCReestablishmentRequest(uint8_t Mod_id, uint8_t *buffer, uint16_t c
 }
 
 //------------------------------------------------------------------------------
-int do_RRCReestablishment(const protocol_ctxt_t *const ctxt_pP,
-                          rrc_gNB_ue_context_t *const ue_context_pP,
+int do_RRCReestablishment(rrc_gNB_ue_context_t *const ue_context_pP,
                           int CC_id,
                           uint8_t *const buffer,
                           size_t buffer_size,
@@ -1126,7 +1125,8 @@ int do_RRCReestablishment(const protocol_ctxt_t *const ctxt_pP,
   rrcReestablishment->criticalExtensions.present = NR_RRCReestablishment__criticalExtensions_PR_rrcReestablishment;
   rrcReestablishment->criticalExtensions.choice.rrcReestablishment = CALLOC(1, sizeof(NR_RRCReestablishment_IEs_t));
 
-  uint16_t pci = RC.nrrrc[ctxt_pP->module_id]->carrier.physCellId;
+  int module_id = 0;
+  uint16_t pci = RC.nrrrc[module_id]->carrier.physCellId;
   uint32_t nr_arfcn_dl = (uint64_t)*scc->downlinkConfigCommon->frequencyInfoDL->absoluteFrequencySSB;
   LOG_I(NR_RRC, "Reestablishment update key pci=%d, earfcn_dl=%u\n", pci, nr_arfcn_dl);
 

openair2/RRC/NR/MESSAGES/asn1_msg.h

@@ -172,8 +172,7 @@ uint8_t do_NR_ULInformationTransfer(uint8_t **buffer,
 
 uint8_t do_RRCReestablishmentRequest(uint8_t Mod_id, uint8_t *buffer, uint16_t c_rnti);
 
-int do_RRCReestablishment(const protocol_ctxt_t *const ctxt_pP,
-                          rrc_gNB_ue_context_t *const ue_context_pP,
+int do_RRCReestablishment(rrc_gNB_ue_context_t *const ue_context_pP,
                           int CC_id,
                           uint8_t *const buffer,
                           size_t buffer_size,

openair2/RRC/NR/cucp_cuup_direct.c

@@ -61,7 +61,7 @@ void fill_e1ap_bearer_setup_resp(e1ap_bearer_setup_resp_t *resp,
       drbSetup->numUpParam = 1;
       drbSetup->UpParamList[0].tlAddress = my_addr;
       drbSetup->UpParamList[0].teId = newGtpuCreateTunnel(gtpInst,
-                                                          (ue_id & 0xFFFF),
+                                                          ue_id,
                                                           drb2Setup->id,
                                                           drb2Setup->id,
                                                           0xFFFF, // We will set the right value from DU answer
@@ -117,7 +117,7 @@ static int drb_config_gtpu_create(const protocol_ctxt_t *const ctxt_p,
     create_tunnel_req.outgoing_teid[i] = pdu->param.gtp_teid;
   }
   create_tunnel_req.num_tunnels = UE->nb_of_pdusessions;
-  create_tunnel_req.ue_id = UE->rnti;
+  create_tunnel_req.ue_id = UE->rrc_ue_id;
   int ret = gtpv1u_create_ngu_tunnel(getCxtE1(instance)->gtpInstN3,
                                      &create_tunnel_req,
                                      &create_tunnel_resp,
@@ -150,8 +150,7 @@ static int drb_config_gtpu_create(const protocol_ctxt_t *const ctxt_p,
 
   LOG_D(NR_RRC, "Configuring PDCP DRBs for UE %x\n", UE->rnti);
   nr_pdcp_add_drbs(ctxt_p->enb_flag,
-                   ctxt_p->rntiMaybeUEid,
-                   0,
+                   UE->rrc_ue_id,
                    DRB_configList,
                    (UE->integrity_algorithm << 4) | UE->ciphering_algorithm,
                    kUPenc,
@@ -163,10 +162,10 @@ static int drb_config_gtpu_create(const protocol_ctxt_t *const ctxt_p,
 
 static void cucp_cuup_bearer_context_setup_direct(e1ap_bearer_setup_req_t *const req, instance_t instance)
 {
-  rrc_gNB_ue_context_t *ue_context_p = rrc_gNB_get_ue_context_by_rnti(RC.nrrrc[instance], req->rnti);
+  rrc_gNB_ue_context_t *ue_context_p = rrc_gNB_get_ue_context(RC.nrrrc[instance], req->gNB_cu_cp_ue_id);
   gNB_RRC_UE_t *UE = &ue_context_p->ue_context;
   protocol_ctxt_t ctxt = {0};
-  PROTOCOL_CTXT_SET_BY_MODULE_ID(&ctxt, 0, GNB_FLAG_YES, UE->rnti, 0, 0, 0);
+  PROTOCOL_CTXT_SET_BY_MODULE_ID(&ctxt, 0, GNB_FLAG_YES, UE->rrc_ue_id, 0, 0, 0);
 
   e1ap_bearer_setup_resp_t resp = {0};
   resp.numPDUSessions = req->numPDUSessions;
@@ -198,7 +197,7 @@ static void cucp_cuup_bearer_context_setup_direct(e1ap_bearer_setup_req_t *const
     in_addr_t my_addr = inet_addr(RC.nrrrc[ctxt.module_id]->eth_params_s.my_addr);
     instance_t gtpInst = getCxt(CUtype, instance)->gtpInst;
     // GTP tunnel for DL
-    fill_e1ap_bearer_setup_resp(&resp, req, gtpInst, UE->rnti, remote_port, my_addr);
+    fill_e1ap_bearer_setup_resp(&resp, req, gtpInst, UE->rrc_ue_id, remote_port, my_addr);
   }
   // actually, we should receive the corresponding context setup response
   // message at the RRC and always react to this one. So in the following, we
@@ -212,7 +211,7 @@ static void cucp_cuup_bearer_context_mod_direct(e1ap_bearer_setup_req_t *const r
   if (!NODE_IS_CU(RC.nrrrc[0]->node_type))
     return;
   instance_t gtpInst = getCxt(CUtype, instance)->gtpInst;
-  CU_update_UP_DL_tunnel(req, gtpInst, req->rnti);
+  CU_update_UP_DL_tunnel(req, gtpInst, req->gNB_cu_cp_ue_id);
 }
 
 void cucp_cuup_message_transfer_direct_init(gNB_RRC_INST *rrc) {

openair2/RRC/NR/mac_rrc_dl.h

@@ -29,7 +29,7 @@ typedef void (*ue_context_setup_request_func_t)(const f1ap_ue_context_setup_t *r
 typedef void (*ue_context_modification_request_func_t)(const f1ap_ue_context_modif_req_t *req);
 typedef void (*ue_context_release_command_func_t)(const f1ap_ue_context_release_cmd_t *cmd);
 
-typedef void (*dl_rrc_message_transfer_func_t)(module_id_t module_id, const f1ap_dl_rrc_message_t *dl_rrc);
+typedef void (*dl_rrc_message_transfer_func_t)(const f1ap_dl_rrc_message_t *dl_rrc);
 
 struct nr_mac_rrc_dl_if_s;
 void mac_rrc_dl_direct_init(struct nr_mac_rrc_dl_if_s *mac_rrc);

openair2/RRC/NR/mac_rrc_dl_direct.c

@@ -24,17 +24,10 @@
 #include "mac_rrc_dl.h"
 #include "openair2/LAYER2/NR_MAC_gNB/mac_rrc_dl_handler.h"
 
-static void dl_rrc_message_transfer_direct(module_id_t module_id, const f1ap_dl_rrc_message_t *dl_rrc)
-{
-  /* TODO how to manage inter-thread communication? */
-
-  dl_rrc_message(module_id, dl_rrc);
-}
-
 void mac_rrc_dl_direct_init(nr_mac_rrc_dl_if_t *mac_rrc)
 {
   mac_rrc->ue_context_setup_request = ue_context_setup_request;
   mac_rrc->ue_context_modification_request = ue_context_modification_request;
   mac_rrc->ue_context_release_command = ue_context_release_command;
-  mac_rrc->dl_rrc_message_transfer = dl_rrc_message_transfer_direct;
+  mac_rrc->dl_rrc_message_transfer = dl_rrc_message_transfer;
 }

openair2/RRC/NR/mac_rrc_dl_f1ap.c

@@ -76,23 +76,34 @@ static void ue_context_release_command_f1ap(const f1ap_ue_context_release_cmd_t
   MessageDef *message_p = itti_alloc_new_message (TASK_RRC_GNB, 0, F1AP_UE_CONTEXT_RELEASE_CMD);
   f1ap_ue_context_release_cmd_t *msg = &F1AP_UE_CONTEXT_RELEASE_CMD(message_p);
   *msg = *cmd;
+  if (cmd->rrc_container_length > 0) {
+    msg->rrc_container = calloc(cmd->rrc_container_length, sizeof(*msg->rrc_container));
+    AssertFatal(msg->rrc_container != NULL, "out of memory\n");
+    msg->rrc_container_length = cmd->rrc_container_length;
+    memcpy(msg->rrc_container, cmd->rrc_container, cmd->rrc_container_length);
+  }
   itti_send_msg_to_task (TASK_CU_F1, 0, message_p);
 }
 
-static void dl_rrc_message_transfer_f1ap(module_id_t module_id, const f1ap_dl_rrc_message_t *dl_rrc)
+static void dl_rrc_message_transfer_f1ap(const f1ap_dl_rrc_message_t *dl_rrc)
 {
   /* TODO call F1AP function directly? no real-time constraint here */
 
   MessageDef *message_p = itti_alloc_new_message (TASK_RRC_GNB, 0, F1AP_DL_RRC_MESSAGE);
   f1ap_dl_rrc_message_t *msg = &F1AP_DL_RRC_MESSAGE(message_p);
   *msg = *dl_rrc;
+  if (dl_rrc->old_gNB_DU_ue_id) {
+    msg->old_gNB_DU_ue_id = malloc(sizeof(*msg->old_gNB_DU_ue_id));
+    AssertFatal(msg->old_gNB_DU_ue_id != NULL, "out of memory\n");
+    *msg->old_gNB_DU_ue_id = *dl_rrc->old_gNB_DU_ue_id;
+  }
   if (dl_rrc->rrc_container) {
     msg->rrc_container = malloc(dl_rrc->rrc_container_length);
     AssertFatal(msg->rrc_container != NULL, "out of memory\n");
     msg->rrc_container_length = dl_rrc->rrc_container_length;
     memcpy(msg->rrc_container, dl_rrc->rrc_container, dl_rrc->rrc_container_length);
   }
-  itti_send_msg_to_task (TASK_CU_F1, module_id, message_p);
+  itti_send_msg_to_task (TASK_CU_F1, 0, message_p);
 }
 
 void mac_rrc_dl_f1ap_init(nr_mac_rrc_dl_if_t *mac_rrc)

openair2/RRC/NR/nr_rrc_defs.h

@@ -235,7 +235,6 @@ typedef enum {
 } rrc_action_t;
 
 typedef struct gNB_RRC_UE_s {
-  uint8_t primaryCC_id;
   drb_t                              established_drbs[MAX_DRBS_PER_UE];
   uint8_t                            DRB_active[MAX_DRBS_PER_UE];
 
@@ -255,9 +254,6 @@ typedef struct gNB_RRC_UE_s {
   NR_RRCReconfiguration_t            *reconfig;
   NR_RadioBearerConfig_t             *rb_config;
 
-  /* Pointer to save spCellConfig during RRC Reestablishment procedures */
-  NR_SpCellConfig_t                  *spCellConfigReestablishment;
-
   ImsiMobileIdentity_t               imsi;
 
   /* KgNB as derived from KASME received from EPC */
@@ -283,12 +279,7 @@ typedef struct gNB_RRC_UE_s {
   /* Information from UE RRCReestablishmentRequest */
   NR_ReestablishmentCause_t          reestablishment_cause;
 
-  /* UE id for initial connection to S1AP */
-  uint16_t                           ue_initial_id;
-
-  /* Information from S1AP initial_context_setup_req */
-  uint32_t                           gNB_ue_s1ap_id :24;
-  uint32_t                           gNB_ue_ngap_id;
+  uint32_t                           rrc_ue_id;
   uint64_t amf_ue_ngap_id;
   nr_rrc_guami_t                     ue_guami;
 
@@ -383,11 +374,6 @@ typedef struct cucp_cuup_if_s {
   cucp_cuup_bearer_context_setup_func_t bearer_context_mod;
 } cucp_cuup_if_t;
 
-typedef struct nr_reestablish_rnti_map_s {
-  ue_id_t ue_id;
-  rnti_t c_rnti;
-} nr_reestablish_rnti_map_t;
-
 //---NR---(completely change)---------------------
 typedef struct gNB_RRC_INST_s {
 
@@ -435,8 +421,6 @@ typedef struct gNB_RRC_INST_s {
   // security configuration (preferred algorithms)
   nr_security_configuration_t security;
 
-  nr_reestablish_rnti_map_t nr_reestablish_rnti_map[MAX_MOBILES_PER_GNB];
-
   nr_mac_rrc_dl_if_t mac_rrc;
   cucp_cuup_if_t cucp_cuup;
 

openair2/RRC/NR/nr_rrc_proto.h

@@ -119,7 +119,6 @@ void *rrc_gnb_task(void *args_p);
    \ *reOffset Pointer to RE Offset Value */
 void rrc_config_dl_ptrs_params(NR_BWP_Downlink_t *bwp, long *ptrsNrb, long *ptrsMcs, long *epre_Ratio, long *reOffset);
 
-void nr_rrc_mac_remove_ue(rnti_t rntiP);
 void nr_rrc_mac_update_cellgroup(rnti_t rntiMaybeUEid, NR_CellGroupConfig_t *cgc);
 
 int8_t nr_mac_rrc_bwp_switch_req(const module_id_t     module_idP,
@@ -164,7 +163,6 @@ void nr_pdcp_add_srbs(eNB_flag_t enb_flag, ue_id_t rntiMaybeUEid, NR_SRB_ToAddMo
 
 void nr_pdcp_add_drbs(eNB_flag_t enb_flag,
                       ue_id_t rntiMaybeUEid,
-                      ue_id_t reestablish_ue_id,
                       NR_DRB_ToAddModList_t *const drb2add_list,
                       const uint8_t security_modeP,
                       uint8_t *const kUPenc,
@@ -172,4 +170,7 @@ void nr_pdcp_add_drbs(eNB_flag_t enb_flag,
                       struct NR_CellGroupConfig__rlc_BearerToAddModList *rlc_bearer2add_list);
 
 int rrc_gNB_generate_pcch_msg(uint32_t tmsi, uint8_t paging_drx, instance_t instance, uint8_t CC_id);
+
+void nr_rrc_transfer_protected_rrc_message(const gNB_RRC_INST *rrc, const gNB_RRC_UE_t *ue_p, uint8_t srb_id, const uint8_t* buffer, int size);
+
 #endif

openair2/RRC/NR/rrc_gNB_GTPV1U.c

@@ -52,7 +52,8 @@ int rrc_gNB_process_GTPV1U_CREATE_TUNNEL_RESP(const protocol_ctxt_t *const ctxt_
   }
 
   LOG_D(RRC, PROTOCOL_RRC_CTXT_UE_FMT " RX CREATE_TUNNEL_RESP num tunnels %u \n", PROTOCOL_RRC_CTXT_UE_ARGS(ctxt_pP), create_tunnel_resp_pP->num_tunnels);
-  rrc_gNB_ue_context_t *ue_context_p = rrc_gNB_get_ue_context_by_rnti(RC.nrrrc[ctxt_pP->module_id], ctxt_pP->rntiMaybeUEid);
+  /* we look up by CU UE ID! Do NOT change back to RNTI! */
+  rrc_gNB_ue_context_t *ue_context_p = rrc_gNB_get_ue_context(RC.nrrrc[ctxt_pP->module_id], ctxt_pP->rntiMaybeUEid);
   if (!ue_context_p) {
     LOG_E(NR_RRC, "UE table error\n");
     return -1;
@@ -83,7 +84,8 @@ int nr_rrc_gNB_process_GTPV1U_CREATE_TUNNEL_RESP(const protocol_ctxt_t *const ct
   }
 
   LOG_D(NR_RRC, PROTOCOL_NR_RRC_CTXT_UE_FMT " RX CREATE_TUNNEL_RESP num tunnels %u \n", PROTOCOL_NR_RRC_CTXT_UE_ARGS(ctxt_pP), create_tunnel_resp_pP->num_tunnels);
-  rrc_gNB_ue_context_t *ue_context_p = rrc_gNB_get_ue_context_by_rnti(RC.nrrrc[ctxt_pP->module_id], ctxt_pP->rntiMaybeUEid);
+  /* we look up by CU UE ID! Do NOT change back to RNTI! */
+  rrc_gNB_ue_context_t *ue_context_p = rrc_gNB_get_ue_context(RC.nrrrc[ctxt_pP->module_id], ctxt_pP->rntiMaybeUEid);
   if (!ue_context_p) {
     LOG_E(NR_RRC, "UE table error\n");
     return -1;

openair2/RRC/NR/rrc_gNB_NGAP.c

@@ -58,6 +58,7 @@
 #include "NR_UE-CapabilityRAT-ContainerList.h"
 #include "NGAP_CauseRadioNetwork.h"
 #include "f1ap_messages_types.h"
+#include "openair2/F1AP/f1ap_ids.h"
 #include "openair2/E1AP/e1ap_asnc.h"
 #include "NGAP_asn_constant.h"
 #include "NGAP_PDUSessionResourceSetupRequestTransfer.h"
@@ -182,7 +183,7 @@ rrc_gNB_send_NGAP_NAS_FIRST_REQ(
   ngap_nas_first_req_t *req = &NGAP_NAS_FIRST_REQ(message_p);
   memset(req, 0, sizeof(*req));
 
-  req->gNB_ue_ngap_id = UE->gNB_ue_ngap_id;
+  req->gNB_ue_ngap_id = UE->rrc_ue_id;
 
   /* Assume that cause is coded in the same way in RRC and NGap, just check that the value is in NGap range */
   AssertFatal(UE->establishment_cause < NGAP_RRC_CAUSE_LAST, "Establishment cause invalid (%jd/%d) for gNB %d!", UE->establishment_cause, NGAP_RRC_CAUSE_LAST, ctxt_pP->module_id);
@@ -370,7 +371,7 @@ int rrc_gNB_process_NGAP_INITIAL_CONTEXT_SETUP_REQ(MessageDef *msg_p, instance_t
     itti_send_msg_to_task(TASK_NGAP, instance, msg_fail_p);
     return (-1);
   }
-  PROTOCOL_CTXT_SET_BY_INSTANCE(&ctxt, instance, GNB_FLAG_YES, UE->rnti, 0, 0);
+  PROTOCOL_CTXT_SET_BY_INSTANCE(&ctxt, instance, GNB_FLAG_YES, UE->rrc_ue_id, 0, 0);
   UE->amf_ue_ngap_id = req->amf_ue_ngap_id;
   uint8_t nb_pdusessions_tosetup = req->nb_of_pdusessions;
   if (nb_pdusessions_tosetup) {
@@ -391,7 +392,7 @@ int rrc_gNB_process_NGAP_INITIAL_CONTEXT_SETUP_REQ(MessageDef *msg_p, instance_t
       memcpy(create_tunnel_req.dst_addr[i].buffer, req->pdusession_param[i].upf_addr.buffer, sizeof(create_tunnel_req.dst_addr[i].buffer));
       LOG_I(NR_RRC, "PDUSESSION SETUP: local index %d teid %u, pdusession id %d \n", i, create_tunnel_req.outgoing_teid[i], create_tunnel_req.pdusession_id[i]);
     }
-    create_tunnel_req.ue_id = UE->rnti;
+    create_tunnel_req.ue_id = UE->rrc_ue_id;
     gtpv1u_gnb_create_tunnel_resp_t create_tunnel_resp = {0};
     int ret = gtpv1u_create_ngu_tunnel(instance, &create_tunnel_req, &create_tunnel_resp, nr_pdcp_data_req_drb, sdap_data_req);
     if (ret != 0) {
@@ -436,7 +437,7 @@ void rrc_gNB_send_NGAP_INITIAL_CONTEXT_SETUP_RESP(const protocol_ctxt_t *const c
   ngap_initial_context_setup_resp_t *resp = &NGAP_INITIAL_CONTEXT_SETUP_RESP(msg_p);
   gNB_RRC_UE_t *UE = &ue_context_pP->ue_context;
 
-  resp->gNB_ue_ngap_id = UE->gNB_ue_ngap_id;
+  resp->gNB_ue_ngap_id = UE->rrc_ue_id;
 
   for (int pdusession = 0; pdusession < UE->nb_of_pdusessions; pdusession++) {
     rrc_pdu_session_param_t *session = &UE->pduSession[pdusession];
@@ -607,7 +608,7 @@ int rrc_gNB_process_NGAP_DOWNLINK_NAS(MessageDef *msg_p, instance_t instance, mu
   }
 
   gNB_RRC_UE_t *UE = &ue_context_p->ue_context;
-  PROTOCOL_CTXT_SET_BY_INSTANCE(&ctxt, instance, GNB_FLAG_YES, UE->rnti, 0, 0);
+  PROTOCOL_CTXT_SET_BY_INSTANCE(&ctxt, instance, GNB_FLAG_YES, UE->rrc_ue_id, 0, 0);
 
   /* Create message for PDCP (DLInformationTransfer_t) */
   length = do_NR_DLInformationTransfer(instance, &buffer, rrc_gNB_get_next_transaction_identifier(instance), req->nas_pdu.length, req->nas_pdu.buffer);
@@ -618,7 +619,7 @@ int rrc_gNB_process_NGAP_DOWNLINK_NAS(MessageDef *msg_p, instance_t instance, mu
   AssertFatal(!NODE_IS_DU(RC.nrrrc[ctxt.module_id]->node_type), "illegal node type DU: receiving NGAP messages at this node\n");
   /* Transfer data to PDCP */
   rb_id_t srb_id = UE->Srb[2].Active ? DCCH1 : DCCH;
-  nr_pdcp_data_req_srb(ctxt.rntiMaybeUEid, srb_id, (*rrc_gNB_mui)++, length, buffer, deliver_pdu_srb_f1, RC.nrrrc[instance]);
+  nr_rrc_transfer_protected_rrc_message(RC.nrrrc[instance], UE, srb_id, buffer, length);
   return 0;
 }
 
@@ -641,7 +642,7 @@ rrc_gNB_send_NGAP_UPLINK_NAS(
         pdu_length = ulInformationTransfer->criticalExtensions.choice.ulInformationTransfer->dedicatedNAS_Message->size;
         pdu_buffer = ulInformationTransfer->criticalExtensions.choice.ulInformationTransfer->dedicatedNAS_Message->buf;
         msg_p = itti_alloc_new_message (TASK_RRC_GNB, 0, NGAP_UPLINK_NAS);
-        NGAP_UPLINK_NAS(msg_p).gNB_ue_ngap_id = UE->gNB_ue_ngap_id;
+        NGAP_UPLINK_NAS(msg_p).gNB_ue_ngap_id = UE->rrc_ue_id;
         NGAP_UPLINK_NAS (msg_p).nas_pdu.length = pdu_length;
         NGAP_UPLINK_NAS (msg_p).nas_pdu.buffer = pdu_buffer;
         // extract_imsi(NGAP_UPLINK_NAS (msg_p).nas_pdu.buffer,
@@ -668,7 +669,7 @@ rrc_gNB_send_NGAP_PDUSESSION_SETUP_RESP(
   msg_p = itti_alloc_new_message (TASK_RRC_GNB, 0, NGAP_PDUSESSION_SETUP_RESP);
   ngap_pdusession_setup_resp_t *resp = &NGAP_PDUSESSION_SETUP_RESP(msg_p);
   gNB_RRC_UE_t *UE = &ue_context_pP->ue_context;
-  resp->gNB_ue_ngap_id = UE->gNB_ue_ngap_id;
+  resp->gNB_ue_ngap_id = UE->rrc_ue_id;
 
   for (int pdusession = 0; pdusession < UE->nb_of_pdusessions; pdusession++) {
     rrc_pdu_session_param_t *session = &UE->pduSession[pdusession];
@@ -745,7 +746,7 @@ void rrc_gNB_process_NGAP_PDUSESSION_SETUP_REQ(MessageDef *msg_p, instance_t ins
     return ;
   }
 
-  UE->gNB_ue_ngap_id = msg->gNB_ue_ngap_id;
+  UE->rrc_ue_id = msg->gNB_ue_ngap_id;
   UE->amf_ue_ngap_id = msg->amf_ue_ngap_id;
   e1ap_bearer_setup_req_t bearer_req = {0};
 
@@ -759,7 +760,6 @@ void rrc_gNB_process_NGAP_PDUSESSION_SETUP_REQ(MessageDef *msg_p, instance_t ins
     session->pdusessionTransfer = msg->pdusession_setup_params[i].pdusessionTransfer;
     decodePDUSessionResourceSetup(session);
     bearer_req.gNB_cu_cp_ue_id = msg->gNB_ue_ngap_id;
-    bearer_req.rnti = UE->rnti;
     bearer_req.cipheringAlgorithm = UE->ciphering_algorithm;
     bearer_req.integrityProtectionAlgorithm = UE->integrity_algorithm;
     nr_derive_key(UP_ENC_ALG, UE->ciphering_algorithm, UE->kgnb, (uint8_t *)bearer_req.encryptionKey);
@@ -925,7 +925,7 @@ int rrc_gNB_process_NGAP_PDUSESSION_MODIFY_REQ(MessageDef *msg_p, instance_t ins
     return (-1);
   }
   gNB_RRC_UE_t *UE = &ue_context_p->ue_context;
-  PROTOCOL_CTXT_SET_BY_INSTANCE(&ctxt, instance, GNB_FLAG_YES, UE->rnti, 0, 0);
+  PROTOCOL_CTXT_SET_BY_INSTANCE(&ctxt, instance, GNB_FLAG_YES, UE->rrc_ue_id, 0, 0);
   ctxt.eNB_index = 0;
   bool all_failed = true;
   for (int i = 0; i < req->nb_pdusessions_tomodify; i++) {
@@ -1009,7 +1009,7 @@ rrc_gNB_send_NGAP_PDUSESSION_MODIFY_RESP(
   ngap_pdusession_modify_resp_t *resp = &NGAP_PDUSESSION_MODIFY_RESP(msg_p);
   LOG_I(NR_RRC, "send message NGAP_PDUSESSION_MODIFY_RESP \n");
 
-  resp->gNB_ue_ngap_id = UE->gNB_ue_ngap_id;
+  resp->gNB_ue_ngap_id = UE->rrc_ue_id;
 
   for (int i = 0; i < UE->nb_of_pdusessions; i++) {
     if (xid != UE->pduSession[i].xid) {
@@ -1087,7 +1087,7 @@ void rrc_gNB_send_NGAP_UE_CONTEXT_RELEASE_REQ(const module_id_t gnb_mod_idP, con
     MessageDef *msg = itti_alloc_new_message(TASK_RRC_GNB, 0, NGAP_UE_CONTEXT_RELEASE_REQ);
     ngap_ue_release_req_t *req = &NGAP_UE_CONTEXT_RELEASE_REQ(msg);
     memset(req, 0, sizeof(*req));
-    req->gNB_ue_ngap_id = UE->gNB_ue_ngap_id;
+    req->gNB_ue_ngap_id = UE->rrc_ue_id;
     req->cause = causeP;
     req->cause_value = cause_valueP;
     for (int i = 0; i < UE->nb_of_pdusessions; i++) {
@@ -1152,7 +1152,7 @@ int rrc_gNB_process_NGAP_UE_CONTEXT_RELEASE_COMMAND(MessageDef *msg_p, instance_
   }
 
   gNB_RRC_UE_t *UE = &ue_context_p->ue_context;
-  PROTOCOL_CTXT_SET_BY_INSTANCE(&ctxt, instance, GNB_FLAG_YES, UE->rnti, 0, 0);
+  PROTOCOL_CTXT_SET_BY_INSTANCE(&ctxt, instance, GNB_FLAG_YES, UE->rrc_ue_id, 0, 0);
   ctxt.eNB_index = 0;
   rrc_gNB_generate_RRCRelease(&ctxt, ue_context_p);
   return 0;
@@ -1202,7 +1202,7 @@ void rrc_gNB_send_NGAP_UE_CAPABILITIES_IND(const protocol_ctxt_t *const ctxt_pP,
     msg_p = itti_alloc_new_message (TASK_RRC_GNB, 0, NGAP_UE_CAPABILITIES_IND);
     ngap_ue_cap_info_ind_t *ind = &NGAP_UE_CAPABILITIES_IND(msg_p);
     memset(ind, 0, sizeof(*ind));
-    ind->gNB_ue_ngap_id = UE->gNB_ue_ngap_id;
+    ind->gNB_ue_ngap_id = UE->rrc_ue_id;
     ind->ue_radio_cap.length = encoded;
     ind->ue_radio_cap.buffer = buf2;
     itti_send_msg_to_task (TASK_NGAP, ctxt_pP->instance, msg_p);
@@ -1224,7 +1224,7 @@ rrc_gNB_send_NGAP_PDUSESSION_RELEASE_RESPONSE(
   msg_p = itti_alloc_new_message (TASK_RRC_GNB, 0, NGAP_PDUSESSION_RELEASE_RESPONSE);
   ngap_pdusession_release_resp_t *resp = &NGAP_PDUSESSION_RELEASE_RESPONSE(msg_p);
   memset(resp, 0, sizeof(*resp));
-  resp->gNB_ue_ngap_id = UE->gNB_ue_ngap_id;
+  resp->gNB_ue_ngap_id = UE->rrc_ue_id;
 
   for (int i = 0; i < UE->nb_of_pdusessions; i++) {
     if (xid == UE->pduSession[i].xid) {
@@ -1239,7 +1239,7 @@ rrc_gNB_send_NGAP_PDUSESSION_RELEASE_RESPONSE(
 
   resp->nb_of_pdusessions_released = pdu_sessions_released;
   resp->nb_of_pdusessions_failed = 0;
-  LOG_I(NR_RRC, "NGAP PDUSESSION RELEASE RESPONSE: GNB_UE_NGAP_ID %u release_pdu_sessions %d\n", resp->gNB_ue_ngap_id, pdu_sessions_released);
+  LOG_I(NR_RRC, "NGAP PDUSESSION RELEASE RESPONSE: rrc_ue_id %u release_pdu_sessions %d\n", resp->gNB_ue_ngap_id, pdu_sessions_released);
   itti_send_msg_to_task (TASK_NGAP, ctxt_pP->instance, msg_p);
 }
 
@@ -1264,9 +1264,9 @@ int rrc_gNB_process_NGAP_PDUSESSION_RELEASE_COMMAND(MessageDef *msg_p, instance_
 
   LOG_I(NR_RRC, "[gNB %ld] gNB_ue_ngap_id %u \n", instance, gNB_ue_ngap_id);
   gNB_RRC_UE_t *UE = &ue_context_p->ue_context;
-  PROTOCOL_CTXT_SET_BY_INSTANCE(&ctxt, instance, GNB_FLAG_YES, UE->rnti, 0, 0);
+  PROTOCOL_CTXT_SET_BY_INSTANCE(&ctxt, instance, GNB_FLAG_YES, UE->rrc_ue_id, 0, 0);
   LOG_I(
-      NR_RRC, "PDU Session Release Command: AMF_UE_NGAP_ID %lu  GNB_UE_NGAP_ID %u release_pdusessions %d \n", cmd->amf_ue_ngap_id, gNB_ue_ngap_id, cmd->nb_pdusessions_torelease);
+      NR_RRC, "PDU Session Release Command: AMF_UE_NGAP_ID %lu  rrc_ue_id %u release_pdusessions %d \n", cmd->amf_ue_ngap_id, gNB_ue_ngap_id, cmd->nb_pdusessions_torelease);
   bool found = false;
   uint8_t xid = rrc_gNB_get_next_transaction_identifier(ctxt.module_id);
   UE->xids[xid] = RRC_PDUSESSION_RELEASE;

openair2/RRC/NR/rrc_gNB_UE_context.c

@@ -35,17 +35,18 @@
 
 #include "common/utils/LOG/log.h"
 #include "rrc_gNB_UE_context.h"
+#include "openair2/F1AP/f1ap_ids.h"
 
 
 //------------------------------------------------------------------------------
 int rrc_gNB_compare_ue_rnti_id(rrc_gNB_ue_context_t *c1_pP, rrc_gNB_ue_context_t *c2_pP)
 //------------------------------------------------------------------------------
 {
-  if (c1_pP->ue_context.gNB_ue_ngap_id > c2_pP->ue_context.gNB_ue_ngap_id) {
+  if (c1_pP->ue_context.rrc_ue_id > c2_pP->ue_context.rrc_ue_id) {
     return 1;
   }
 
-  if (c1_pP->ue_context.gNB_ue_ngap_id < c2_pP->ue_context.gNB_ue_ngap_id) {
+  if (c1_pP->ue_context.rrc_ue_id < c2_pP->ue_context.rrc_ue_id) {
     return -1;
   }
 
@@ -66,12 +67,12 @@ rrc_gNB_ue_context_t *rrc_gNB_allocate_new_ue_context(gNB_RRC_INST *rrc_instance
     LOG_E(NR_RRC, "Cannot allocate new ue context\n");
     return NULL;
   }
-  new_p->ue_context.gNB_ue_ngap_id = uid_linear_allocator_new(&rrc_instance_pP->uid_allocator);
+  new_p->ue_context.rrc_ue_id = uid_linear_allocator_new(&rrc_instance_pP->uid_allocator) + 1;
 
   for(int i = 0; i < NB_RB_MAX; i++)
     new_p->ue_context.pduSession[i].xid = -1;
 
-  LOG_I(NR_RRC, "Returning new RRC UE context RRC ue id: %d\n", new_p->ue_context.gNB_ue_ngap_id);
+  LOG_I(NR_RRC, "Returning new RRC UE context RRC ue id: %d\n", new_p->ue_context.rrc_ue_id);
   return(new_p);
 }
 
@@ -82,7 +83,7 @@ rrc_gNB_ue_context_t *rrc_gNB_get_ue_context(gNB_RRC_INST *rrc_instance_pP, ue_i
 {
   rrc_gNB_ue_context_t temp;
   /* gNB ue rrc id = 24 bits wide */
-  temp.ue_context.gNB_ue_ngap_id = ue;
+  temp.ue_context.rrc_ue_id = ue;
   return RB_FIND(rrc_nr_ue_tree_s, &rrc_instance_pP->rrc_ue_head, &temp);
 }
 
@@ -120,7 +121,8 @@ void rrc_gNB_remove_ue_context(gNB_RRC_INST *rrc_instance_pP, rrc_gNB_ue_context
   }
 
   RB_REMOVE(rrc_nr_ue_tree_s, &rrc_instance_pP->rrc_ue_head, ue_context_pP);
-  uid_linear_allocator_free(&rrc_instance_pP->uid_allocator, ue_context_pP->ue_context.gNB_ue_ngap_id);
+  uid_linear_allocator_free(&rrc_instance_pP->uid_allocator, ue_context_pP->ue_context.rrc_ue_id - 1);
+  cu_remove_f1_ue_data(ue_context_pP->ue_context.rrc_ue_id);
   rrc_gNB_free_mem_ue_context(ue_context_pP);
   LOG_I(NR_RRC, "Removed UE context\n");
 }
@@ -153,35 +155,33 @@ rrc_gNB_ue_context_t *rrc_gNB_ue_context_5g_s_tmsi_exist(gNB_RRC_INST *rrc_insta
     return NULL;
 }
 
-void rrc_gNB_update_ue_context_rnti(rnti_t rnti, gNB_RRC_INST *rrc_instance_pP, uint32_t gNB_ue_ngap_id)
-{
-  // rnti will need to be a fast access key, with indexing, today it is sequential search
-  // This function will update the index when it will be made
-  rrc_gNB_ue_context_t *ue_context_p = rrc_gNB_get_ue_context(rrc_instance_pP, gNB_ue_ngap_id);
-  if (ue_context_p)
-    ue_context_p->ue_context.rnti = rnti;
-  else
-    LOG_E(NR_RRC, "update rnti on a wrong UE id\n");
-}
 //-----------------------------------------------------------------------------
 // return a new ue context structure if ue_identityP, rnti not found in collection
-rrc_gNB_ue_context_t *rrc_gNB_create_ue_context(rnti_t rnti, gNB_RRC_INST *rrc_instance_pP, const uint64_t ue_identityP)
+rrc_gNB_ue_context_t *rrc_gNB_create_ue_context(rnti_t rnti,
+                                                gNB_RRC_INST *rrc_instance_pP,
+                                                const uint64_t ue_identityP,
+                                                uint32_t du_ue_id)
 //-----------------------------------------------------------------------------
 {
-  rrc_gNB_ue_context_t *ue_context_p = rrc_gNB_get_ue_context_by_rnti(rrc_instance_pP, rnti);
-
-  if (ue_context_p) {
-    LOG_E(NR_RRC, "Cannot create new UE context, already exist rnti: %04x\n", rnti);
-    return ue_context_p;
-  }
-
-  ue_context_p = rrc_gNB_allocate_new_ue_context(rrc_instance_pP);
+  rrc_gNB_ue_context_t *ue_context_p = rrc_gNB_allocate_new_ue_context(rrc_instance_pP);
   if (ue_context_p == NULL)
     return NULL;
 
-  ue_context_p->ue_context.rnti = rnti;
-  ue_context_p->ue_context.random_ue_identity = ue_identityP;
+  gNB_RRC_UE_t *ue = &ue_context_p->ue_context;
+  ue->rnti = rnti;
+  ue->random_ue_identity = ue_identityP;
+  f1_ue_data_t ue_data = {.secondary_ue = du_ue_id};
+  AssertFatal(!cu_exists_f1_ue_data(ue->rrc_ue_id),
+              "UE F1 Context for ID %d already exists, logic bug\n",
+              ue->rrc_ue_id);
+  cu_add_f1_ue_data(ue->rrc_ue_id, &ue_data);
+
   RB_INSERT(rrc_nr_ue_tree_s, &rrc_instance_pP->rrc_ue_head, ue_context_p);
-  LOG_W(NR_RRC, " Created new UE context rnti: %04x, random ue id %lx, RRC ue id %u\n", rnti, ue_identityP, ue_context_p->ue_context.gNB_ue_ngap_id);
+  LOG_I(NR_RRC,
+        "Created new UE context: CU UE ID %u DU UE ID %u (rnti: %04x, random ue id %lx)\n",
+        ue->rrc_ue_id,
+        du_ue_id,
+        ue->rnti,
+        ue->random_ue_identity);
   return ue_context_p;
 }

openair2/RRC/NR/rrc_gNB_UE_context.h

@@ -50,7 +50,9 @@ void rrc_gNB_remove_ue_context(gNB_RRC_INST* rrc_instance_pP, rrc_gNB_ue_context
 rrc_gNB_ue_context_t* rrc_gNB_ue_context_random_exist(gNB_RRC_INST* rrc_instance_pP, const uint64_t ue_identityP);
 
 rrc_gNB_ue_context_t* rrc_gNB_ue_context_5g_s_tmsi_exist(gNB_RRC_INST* rrc_instance_pP, const uint64_t s_TMSI);
-void rrc_gNB_update_ue_context_rnti(rnti_t rnti, gNB_RRC_INST* rrc_instance_pP, uint32_t gNB_ue_ngap_id);
-rrc_gNB_ue_context_t* rrc_gNB_create_ue_context(rnti_t rnti, gNB_RRC_INST* rrc_instance_pP, const uint64_t ue_identityP);
+rrc_gNB_ue_context_t* rrc_gNB_create_ue_context(rnti_t rnti,
+                                                gNB_RRC_INST* rrc_instance_pP,
+                                                const uint64_t ue_identityP,
+                                                uint32_t du_ue_id);
 
 #endif

openair2/RRC/NR/rrc_gNB_nsa.c

@@ -41,6 +41,7 @@
 #include "openair2/LAYER2/NR_MAC_gNB/mac_proto.h"
 #include "openair2/LAYER2/nr_rlc/nr_rlc_oai_api.h"
 #include "openair2/RRC/LTE/rrc_eNB_GTPV1U.h"
+#include "openair2/F1AP/f1ap_ids.h"
 #include "executables/softmodem-common.h"
 #include "executables/nr-softmodem.h"
 #include <openair2/RRC/NR/rrc_gNB_UE_context.h>
@@ -248,14 +249,11 @@ void rrc_add_nsa_user(gNB_RRC_INST *rrc, rrc_gNB_ue_context_t *ue_context_p, x2a
                                                           1,
                                                           1,
                                                           configuration,
-                                                          ue_context_p->ue_context.gNB_ue_ngap_id);
+                                                          ue_context_p->ue_context.rrc_ue_id);
   AssertFatal(UE->secondaryCellGroup != NULL, "out of memory\n");
   xer_fprint(stdout, &asn_DEF_NR_CellGroupConfig, UE->secondaryCellGroup);
 
-  fill_default_reconfig(carrier->servingcellconfigcommon, scc, reconfig_ies, UE->secondaryCellGroup, UE->UE_Capability_nr, configuration, ue_context_p->ue_context.gNB_ue_ngap_id);
-  // the UE context is not yet inserted in the RRC UE manager
-  // rrc_gNB_update_ue_context_rnti(UE->secondaryCellGroup->spCellConfig->reconfigurationWithSync->newUE_Identity, rrc,
-  // UE->gNB_ue_ngap_id);
+  fill_default_reconfig(carrier->servingcellconfigcommon, scc, reconfig_ies, UE->secondaryCellGroup, UE->UE_Capability_nr, configuration, ue_context_p->ue_context.rrc_ue_id);
   UE->rnti = UE->secondaryCellGroup->spCellConfig->reconfigurationWithSync->newUE_Identity;
   NR_CG_Config_t *CG_Config = calloc(1,sizeof(*CG_Config));
   memset((void *)CG_Config,0,sizeof(*CG_Config));
@@ -288,7 +286,7 @@ void rrc_add_nsa_user(gNB_RRC_INST *rrc, rrc_gNB_ue_context_t *ue_context_p, x2a
               create_tunnel_req.sgw_S1u_teid[i]);
       }
 
-      create_tunnel_req.rnti = ue_context_p->ue_context.rnti;
+      create_tunnel_req.rnti = ue_context_p->ue_context.rrc_ue_id;
       create_tunnel_req.num_tunnels    = m->nb_e_rabs_tobeadded;
       RB_INSERT(rrc_nr_ue_tree_s, &RC.nrrrc[rrc->module_id]->rrc_ue_head, ue_context_p);
       PROTOCOL_CTXT_SET_BY_MODULE_ID(&ctxt, rrc->module_id, GNB_FLAG_YES, ue_context_p->ue_context.rnti, 0, 0, rrc->module_id);
@@ -343,20 +341,31 @@ void rrc_add_nsa_user(gNB_RRC_INST *rrc, rrc_gNB_ue_context_t *ue_context_p, x2a
     itti_send_msg_to_task(TASK_X2AP, ENB_MODULE_ID_TO_INSTANCE(0), msg); //Check right id instead of hardcoding
   }
 
+  // below we configure the stack. In SA, we fully adopted F1, meaning that
+  // layers use different IDs (MAC/RLC use RNTI as DU UE ID, above use NGAP ID
+  // as CU UE ID.
+  uint32_t du_ue_id = ue_context_p->ue_context.rnti;
+  static uint32_t rrc_ue_id = 0;
+  rrc_ue_id++;
+  f1_ue_data_t du_ue_data = {.secondary_ue = rrc_ue_id};
+  du_add_f1_ue_data(du_ue_id, &du_ue_data);
+  f1_ue_data_t cu_ue_data = {.secondary_ue = du_ue_id};
+  cu_add_f1_ue_data(rrc_ue_id, &cu_ue_data);
+  LOG_I(RRC, "Assign CU UE ID %d and DU UE ID %d to UE RNTI %04x\n", rrc_ue_id, du_ue_id, ue_context_p->ue_context.rnti);
+
   // configure MAC and RLC
   bool ret = false;
   if (get_softmodem_params()->phy_test) {
     // phytest mode: we don't set up RA, etc
-    ret = nr_mac_add_test_ue(RC.nrmac[rrc->module_id] , ue_context_p->ue_context.rnti, ue_context_p->ue_context.secondaryCellGroup);
+    ret = nr_mac_add_test_ue(RC.nrmac[rrc->module_id], du_ue_id, ue_context_p->ue_context.secondaryCellGroup);
   } else {
     NR_SCHED_LOCK(&RC.nrmac[rrc->module_id]->sched_lock);
-    ret = nr_mac_prepare_ra_ue(RC.nrmac[rrc->module_id], ue_context_p->ue_context.rnti, ue_context_p->ue_context.secondaryCellGroup);
+    ret = nr_mac_prepare_ra_ue(RC.nrmac[rrc->module_id], du_ue_id, ue_context_p->ue_context.secondaryCellGroup);
     NR_SCHED_UNLOCK(&RC.nrmac[rrc->module_id]->sched_lock);
   }
   AssertFatal(ret, "cannot add NSA UE in MAC, aborting\n");
 
-  PROTOCOL_CTXT_SET_BY_MODULE_ID(&ctxt, rrc->module_id, GNB_FLAG_YES, ue_context_p->ue_context.rnti, 0, 0, rrc->module_id);
-  if (get_softmodem_params()->do_ra) ctxt.enb_flag = 0;
+  PROTOCOL_CTXT_SET_BY_MODULE_ID(&ctxt, rrc->module_id, GNB_FLAG_YES, rrc_ue_id, 0, 0, rrc->module_id);
   LOG_W(RRC,
         "Calling RRC PDCP/RLC ASN1 request functions for protocol context %p with module_id %d, rnti %lx, frame %d, subframe %d eNB_index %d \n",
         &ctxt,
@@ -367,14 +376,14 @@ void rrc_add_nsa_user(gNB_RRC_INST *rrc, rrc_gNB_ue_context_t *ue_context_p, x2a
         ctxt.eNB_index);
 
   nr_pdcp_add_drbs(ctxt.enb_flag,
-                   ctxt.rntiMaybeUEid,
-                   0,
+                   rrc_ue_id,
                    ue_context_p->ue_context.rb_config->drb_ToAddModList,
                    (ue_context_p->ue_context.integrity_algorithm << 4) | ue_context_p->ue_context.ciphering_algorithm,
                    kUPenc,
                    kUPint,
                    ue_context_p->ue_context.secondaryCellGroup->rlc_BearerToAddModList);
 
+  ctxt.rntiMaybeUEid = du_ue_id;
   // assume only a single bearer
   const NR_DRB_ToAddModList_t *drb_list = ue_context_p->ue_context.rb_config->drb_ToAddModList;
   DevAssert(drb_list->list.count == 1);

openair2/RRC/NR_UE/rrc_UE.c

@@ -1675,7 +1675,6 @@ int32_t nr_rrc_ue_establish_drb(module_id_t ue_mod_idP,
      // Refresh DRBs
      nr_pdcp_add_drbs(ctxt_pP->enb_flag,
                       ctxt_pP->rntiMaybeUEid,
-                      0,
                       radioBearerConfig->drb_ToAddModList,
                       ue_rrc->cipheringAlgorithm | (ue_rrc->integrityProtAlgorithm << 4),
                       kUPenc,

openair3/ocp-gtpu/gtp_itf.cpp

@@ -768,31 +768,31 @@ int gtpv1u_create_ngu_tunnel(const instance_t instance,
   return !GTPNOK;
 }
 
-int gtpv1u_update_ngu_tunnel(const instance_t instanceP, const gtpv1u_gnb_create_tunnel_req_t *const create_tunnel_req_pP, const ue_id_t prior_ue_id)
+int gtpv1u_update_ue_id(const instance_t instanceP, ue_id_t old_ue_id, ue_id_t new_ue_id)
 {
-  LOG_D(GTPU, "[%ld] Update tunnels from UEid %lx to UEid %lx\n", instanceP, prior_ue_id, create_tunnel_req_pP->ue_id);
-
   pthread_mutex_lock(&globGtp.gtp_lock);
 
   auto inst = &globGtp.instances[compatInst(instanceP)];
-  auto it = inst->ue2te_mapping.find(prior_ue_id);
+  auto it = inst->ue2te_mapping.find(old_ue_id);
   if (it == inst->ue2te_mapping.end()) {
-    LOG_W(GTPU, "[%ld] Delete GTP tunnels for UEid: %lx, but no tunnel exits\n", instanceP, prior_ue_id);
+    LOG_W(GTPU, "[%ld] Update GTP tunnels for UEid: %lx, but no tunnel exits\n", instanceP, old_ue_id);
     pthread_mutex_unlock(&globGtp.gtp_lock);
     return GTPNOK;
   }
 
-  for (int i = 0; i < create_tunnel_req_pP->num_tunnels; i++) {
-    teid_t incoming_teid = inst->ue2te_mapping[prior_ue_id].bearers[create_tunnel_req_pP->pdusession_id[i]].teid_incoming;
-    if (globGtp.te2ue_mapping[incoming_teid].ue_id == prior_ue_id) {
-      globGtp.te2ue_mapping[incoming_teid].ue_id = create_tunnel_req_pP->ue_id;
+  for (unsigned i = 0; i < it->second.bearers.size(); ++i) {
+    teid_t incoming_teid = inst->ue2te_mapping[old_ue_id].bearers[i].teid_incoming;
+    if (globGtp.te2ue_mapping[incoming_teid].ue_id == old_ue_id) {
+      globGtp.te2ue_mapping[incoming_teid].ue_id = new_ue_id;
     }
   }
 
-  inst->ue2te_mapping[create_tunnel_req_pP->ue_id] = it->second;
+  inst->ue2te_mapping[new_ue_id] = it->second;
   inst->ue2te_mapping.erase(it);
 
   pthread_mutex_unlock(&globGtp.gtp_lock);
+
+  LOG_I(GTPU, "[%ld] Updated tunnels from UEid %lx to UEid %lx\n", instanceP, old_ue_id, new_ue_id);
   return !GTPNOK;
 }
 

openair3/ocp-gtpu/gtp_itf.h

@@ -76,11 +76,8 @@ extern "C" {
 
   int gtpv1u_delete_ngu_tunnel( const instance_t instance,
                                 gtpv1u_gnb_delete_tunnel_req_t *req);
-  
-  int gtpv1u_update_ngu_tunnel( const instance_t                              instanceP,
-                                const gtpv1u_gnb_create_tunnel_req_t *const  create_tunnel_req_pP,
-                                const ue_id_t                                  prior_rnti
-                                );
+
+  int gtpv1u_update_ue_id(const instance_t instanceP, ue_id_t old_ue_id, ue_id_t new_ue_id);
 
   // New API
   teid_t newGtpuCreateTunnel(instance_t instance,