Merge remote-tracking branch 'origin/sdap-qos-improvements' into integration_2025_w43 (!3519)

Refactor SDAP adaptation work for QoS

This MR is an adaptation of the code introduced in !2703.

The goal is a cleanup and functional refactor of the SDAP/PDCP
integration, that is:

- centralize SDAP configuration logic
- simplify entity creation
- improve robustness of role-based SDAP handling
- prepare the codebase for clean support of DRB reconfiguration and
  teardown flows

More concretely:

1. New sdap_config_t and get_sdap_Config()

  - Introduced an internal struct sdap_config_t to abstract SDAP config
    input
  - Centralized SDAP config parsing into new get_sdap_Config() function
    that translates ASN.1 NR_SDAP_Config into this internal
    representation. This is called during RRC triggered
    (re)configuration procedures.
  - Enable mapping of number of QoS flows > 1

2. Unified role handling with bitmasks

  - Added a bitmask-based entity_role field to track SDAP directions:
    SDAP_UL_RX, SDAP_UL_TX, SDAP_DL_RX, SDAP_DL_TX: header presence was
    determined by simple direction (UE vs gNB) and individual
    is_sdap_rx/tx() checks, however nr_sdap_rx_entity behaves
    differently depending on the direction of the RX entity (DL/UL),
    therefore this change can help enable a more accurate SDAP header
    handling across directions and node types.
  - Replaces old helpers is_sdap_rx() / is_sdap_tx() with internal
    checks against the role bitfield
  - QFI-to-DRB mapping is now annotated with direction for both data and
    control PDUs

3. Simplified DRB and SDAP setup

  - add_drb() in PDCP API now delegates SDAP config processing cleanly
  - new_nr_sdap_entity() is used consistently to register a fresh SDAP
    context for the UE and PDU session.
    - Also, re-use and reconfigure existing SDAP entity if already
      exists.
  - logging has been added to trace mapped QFIs from RRC and resulting
    table entries

4. Improved QFI-to-DRB management

  - Refactored nr_sdap_qfi2drb_map_update() to register QFIs based on
    parsed config
  - Ensures control PDUs are correctly routed even after reconfiguration
  - Extended nr_sdap_ue_qfi2drb_config: perform UL QoS flow to DRB
    mapping configuration for a SDAP entity has already been established
    according to TS 37.324, 5.3 QoS flow to DRB Mapping, 5.3.1
    Configuration Procedures. Handle both UL QoS Flows mapping rules to
    add and to remove. QFIs will now be properly unmapped if specified
    via mappedQoS_FlowsToRelease, this might prevent stale QFI mappings
    from being used incorrectly.
  - nr_sdap_qfi2drb() and sdap_map_ctrl_pdu() now strictly fallback to
    default_drb only if a QFI mapping is missing. Missing default DRB
    now triggers LOG_E() (previously silent or misrouted to DRB 0).

5. Other cleanup

  - Remove dependencies from legacy rb_id_t

doc/SW_archi.md

@@ -325,7 +325,7 @@ The PDCP implementation is secured by a general mutex, akin to the design of the
 
 Initialization of the PDCP layer follows a structure similar to that of the RLC layer. The function `nr_pdcp_layer_init()` initializes PDCP, while a second initialization function, `pdcp_module_init()`, must also be invoked.
 
-To manage UE connections, `nr_pdcp_add_srbs()` is employed for adding UE SRBs in PDCP, while `nr_pdcp_remove_UE()` is used for their removal. Similarly, `nr_pdcp_add_drbs()` adds UE DRBs in PDCP, with `nr_pdcp_remove_UE()` handling their removal.
+To manage UE connections, `nr_pdcp_add_srbs()` is employed for adding UE SRBs in PDCP, while `nr_pdcp_remove_UE()` is used for their removal. Similarly, `nr_pdcp_add_drb()` adds UE DRB in PDCP, with `nr_pdcp_remove_UE()` handling their removal.
 
 ## PDCP Tx flow
 

executables/lte-softmodem.c

@@ -151,7 +151,6 @@ double cpuf;
 bool sdap_data_req(protocol_ctxt_t *ctxt_p,
                    const ue_id_t ue_id,
                    const srb_flag_t srb_flag,
-                   const rb_id_t rb_id,
                    const mui_t mui,
                    const confirm_t confirm,
                    const sdu_size_t sdu_buffer_size,

openair2/LAYER2/nr_pdcp/cucp_cuup_handler.c

@@ -141,6 +141,24 @@ static instance_t get_f1_gtp_instance(void)
   return inst->gtpInst;
 }
 
+/** @brief Add bearer in PDCP/SDAP for 5GC association (SA) */
+static void e1_add_bearers(const int ue_id, const NR_DRB_ToAddModList_t *addMod, const nr_pdcp_entity_security_keys_and_algos_t *sp)
+{
+  for (int i = 0; i < addMod->list.count; i++) {
+    NR_DRB_ToAddMod_t *drb = addMod->list.array[i];
+    DevAssert(drb->cnAssociation);
+    DevAssert(drb->cnAssociation->present != NR_DRB_ToAddMod__cnAssociation_PR_NOTHING);
+    DevAssert(drb->cnAssociation->present == NR_DRB_ToAddMod__cnAssociation_PR_sdap_Config);
+    DevAssert(drb->cnAssociation->choice.sdap_Config);
+    // get SDAP config
+    sdap_config_t sdap = nr_sdap_get_config(GNB_FLAG_YES, drb->cnAssociation->choice.sdap_Config, drb->drb_Identity);
+    // add SDAP entity
+    nr_sdap_addmod_entity(GNB_FLAG_YES, ue_id, sdap);
+    // add PDCP entity
+    nr_pdcp_add_drb(GNB_FLAG_YES, ue_id, drb->pdcp_Config, &sdap, sp);
+  }
+}
+
 void e1_bearer_context_setup(const e1ap_bearer_setup_req_t *req)
 {
   bool need_ue_id_mgmt = e1_used();
@@ -208,11 +226,10 @@ void e1_bearer_context_setup(const e1ap_bearer_setup_req_t *req)
     security_parameters.integrity_algorithm = req->secInfo.integrityProtectionAlgorithm;
     memcpy(security_parameters.ciphering_key, req->secInfo.encryptionKey, NR_K_KEY_SIZE);
     memcpy(security_parameters.integrity_key, req->secInfo.integrityProtectionKey, NR_K_KEY_SIZE);
-    nr_pdcp_add_drbs(true, // set this to notify PDCP that his not UE
-                     cu_up_ue_id,
-                     &DRB_configList,
-                     &security_parameters);
+
+    e1_add_bearers(cu_up_ue_id, &DRB_configList, &security_parameters);
     ASN_STRUCT_RESET(asn_DEF_NR_DRB_ToAddModList, &DRB_configList.list);
+
     if (f1inst >= 0) { /* we have F1(-U) */
       teid_t dummy_teid = 0xffff; // we will update later with answer from DU
       in_addr_t dummy_address = {0}; // IPv4, updated later with answer from DU

openair2/LAYER2/nr_pdcp/nr_pdcp_oai_api.c

@@ -575,75 +575,32 @@ void add_srb(int is_gnb,
   nr_pdcp_manager_unlock(nr_pdcp_ue_manager);
 }
 
-void add_drb(int is_gnb,
-             ue_id_t UEid,
-             struct NR_DRB_ToAddMod *s,
-             const nr_pdcp_entity_security_keys_and_algos_t *security_parameters)
+void nr_pdcp_add_drb(int is_gnb,
+                     const ue_id_t UEid,
+                     const NR_PDCP_Config_t *pdcp,
+                     const sdap_config_t *sdap,
+                     const nr_pdcp_entity_security_keys_and_algos_t *security_parameters)
 {
-  nr_pdcp_entity_t *pdcp_drb;
   nr_pdcp_ue_t *ue;
 
-  int drb_id = s->drb_Identity;
-  if (!s->pdcp_Config || !s->pdcp_Config->drb) {
-    LOG_E(PDCP, "DRB field mandatory present at setup. DRB %d not configured.\n", drb_id);
+  if (!pdcp->drb) {
+    LOG_E(PDCP, "Missing PDCP config. DRB %d not configured.\n", sdap->drb_id);
     return;
   }
 
-  struct NR_PDCP_Config__drb *drb = s->pdcp_Config->drb;
+  struct NR_PDCP_Config__drb *drb = pdcp->drb;
   int sn_size_ul = decode_sn_size_ul(*drb->pdcp_SN_SizeUL);
   int sn_size_dl = decode_sn_size_dl(*drb->pdcp_SN_SizeDL);
   int discard_timer = decode_discard_timer(*drb->discardTimer);
 
-  int has_integrity;
-  int has_ciphering;
-
   /* if pdcp_Config->t_Reordering is not present, it means infinity (-1) */
   int t_reordering = -1;
-  if (s->pdcp_Config->t_Reordering != NULL) {
-    t_reordering = decode_t_reordering(*s->pdcp_Config->t_Reordering);
-  }
-
-  if (drb->integrityProtection != NULL)
-    has_integrity = 1;
-  else
-    has_integrity = 0;
-
-  if (s->pdcp_Config->ext1 != NULL && s->pdcp_Config->ext1->cipheringDisabled != NULL)
-    has_ciphering = 0;
-  else
-    has_ciphering = 1;
-
-  if ((!s->cnAssociation) || s->cnAssociation->present == NR_DRB_ToAddMod__cnAssociation_PR_NOTHING) {
-    LOG_E(PDCP, "fatal, cnAssociation is missing or present is NR_DRB_ToAddMod__cnAssociation_PR_NOTHING\n");
-    exit(-1);
+  if (pdcp->t_Reordering != NULL) {
+    t_reordering = decode_t_reordering(*pdcp->t_Reordering);
   }
 
-  int pdusession_id;
-  bool has_sdap_rx = false;
-  bool has_sdap_tx = false;
-  bool is_sdap_DefaultDRB = false;
-  NR_QFI_t *mappedQFIs2Add = NULL;
-  uint8_t mappedQFIs2AddCount=0;
-  if (s->cnAssociation->present == NR_DRB_ToAddMod__cnAssociation_PR_eps_BearerIdentity)
-     pdusession_id = s->cnAssociation->choice.eps_BearerIdentity;
-  else {
-    if (!s->cnAssociation->choice.sdap_Config) {
-      LOG_E(PDCP,"fatal, sdap_Config is null");
-      exit(-1);
-    }
-    pdusession_id = s->cnAssociation->choice.sdap_Config->pdu_Session;
-    has_sdap_rx = is_sdap_rx(is_gnb, s->cnAssociation->choice.sdap_Config);
-    has_sdap_tx = is_sdap_tx(is_gnb, s->cnAssociation->choice.sdap_Config);
-    is_sdap_DefaultDRB = s->cnAssociation->choice.sdap_Config->defaultDRB == true ? 1 : 0;
-    mappedQFIs2Add = (NR_QFI_t*)s->cnAssociation->choice.sdap_Config->mappedQoS_FlowsToAdd->list.array[0]; 
-    mappedQFIs2AddCount = s->cnAssociation->choice.sdap_Config->mappedQoS_FlowsToAdd->list.count;
-    LOG_D(SDAP, "Captured mappedQoS_FlowsToAdd from RRC: %ld \n", *mappedQFIs2Add);
-  }
-  /* TODO(?): accept different UL and DL SN sizes? */
-  if (sn_size_ul != sn_size_dl) {
-    LOG_E(PDCP, "fatal, bad SN sizes, must be same. ul=%d, dl=%d\n", sn_size_ul, sn_size_dl);
-    exit(1);
-  }
+  int has_integrity = (drb->integrityProtection != NULL) ? 1 : 0;
+  int has_ciphering = (pdcp->ext1 != NULL && pdcp->ext1->cipheringDisabled != NULL) ? 0 : 1;
 
   /* get actual ciphering and integrity algorithm based on pdcp_Config */
   nr_pdcp_entity_security_keys_and_algos_t actual_security_parameters = *security_parameters;
@@ -652,29 +609,33 @@ void add_drb(int is_gnb,
 
   nr_pdcp_manager_lock(nr_pdcp_ue_manager);
   ue = nr_pdcp_manager_get_ue(nr_pdcp_ue_manager, UEid);
-  if (nr_pdcp_get_rb(ue, drb_id, false) != NULL) {
-    LOG_W(PDCP, "warning DRB %d already exist for UE ID %ld, do nothing\n", drb_id, UEid);
+  if (nr_pdcp_get_rb(ue, sdap->drb_id, false) != NULL) {
+    LOG_W(PDCP, "warning DRB %d already exist for UE ID %ld, do nothing\n", sdap->drb_id, UEid);
   } else {
-    pdcp_drb = new_nr_pdcp_entity(NR_PDCP_DRB_AM, is_gnb, drb_id, pdusession_id,
-                                  has_sdap_rx, has_sdap_tx, deliver_sdu_drb, ue,
-                                  is_gnb ?
-                                    deliver_pdu_drb_gnb : deliver_pdu_drb_ue,
-                                  ue,
-                                  sn_size_dl, t_reordering, discard_timer,
-                                  &actual_security_parameters);
-    nr_pdcp_ue_add_drb_pdcp_entity(ue, drb_id, pdcp_drb);
-
-    LOG_I(PDCP, "added drb %d to UE ID %ld\n", drb_id, UEid);
-    /* add new SDAP entity for the PDU session the DRB belongs to */
-    new_nr_sdap_entity(is_gnb,
-                       has_sdap_rx,
-                       has_sdap_tx,
-                       UEid,
-                       pdusession_id,
-                       is_sdap_DefaultDRB,
-                       drb_id,
-                       mappedQFIs2Add,
-                       mappedQFIs2AddCount);
+    // code assumption: same SN size for both DL and UL
+    if (sn_size_ul != sn_size_dl) {
+      LOG_E(PDCP, "fatal, bad SN sizes, must be same. ul=%d, dl=%d\n", sn_size_ul, sn_size_dl);
+      exit(1);
+    }
+
+    // add PDCP entity
+    nr_pdcp_entity_t *pdcp_drb = new_nr_pdcp_entity(NR_PDCP_DRB_AM,
+                                                    is_gnb,
+                                                    sdap->drb_id,
+                                                    sdap->pdusession_id,
+                                                    (sdap->role & (SDAP_UL_RX | SDAP_DL_RX)) != 0,
+                                                    (sdap->role & (SDAP_UL_TX | SDAP_DL_TX)) != 0,
+                                                    deliver_sdu_drb,
+                                                    ue,
+                                                    is_gnb ? deliver_pdu_drb_gnb : deliver_pdu_drb_ue,
+                                                    ue,
+                                                    sn_size_dl,
+                                                    t_reordering,
+                                                    discard_timer,
+                                                    &actual_security_parameters);
+    nr_pdcp_ue_add_drb_pdcp_entity(ue, sdap->drb_id, pdcp_drb);
+
+    LOG_I(PDCP, "Added DRB %d to UE ID %ld\n", sdap->drb_id, UEid);
   }
   nr_pdcp_manager_unlock(nr_pdcp_ue_manager);
 }
@@ -692,22 +653,6 @@ void nr_pdcp_add_srbs(eNB_flag_t enb_flag,
     LOG_W(PDCP, "nr_pdcp_add_srbs() with void list\n");
 }
 
-void nr_pdcp_add_drbs(eNB_flag_t enb_flag,
-                      ue_id_t UEid,
-                      NR_DRB_ToAddModList_t *const drb2add_list,
-                      const nr_pdcp_entity_security_keys_and_algos_t *security_parameters)
-{
-  if (drb2add_list != NULL) {
-    for (int i = 0; i < drb2add_list->list.count; i++) {
-      add_drb(enb_flag,
-              UEid,
-              drb2add_list->list.array[i],
-              security_parameters);
-    }
-  } else
-    LOG_W(PDCP, "nr_pdcp_add_drbs() with void list\n");
-}
-
 uint64_t get_pdcp_optmask(void)
 {
   return pdcp_optmask;

openair2/LAYER2/nr_pdcp/nr_pdcp_oai_api.h

@@ -33,6 +33,7 @@
 #include "nr_pdcp_ue_manager.h"
 struct NR_DRB_ToAddMod;
 struct NR_SRB_ToAddMod;
+struct sdap_configuration_s;
 
 void nr_pdcp_layer_init(void);
 
@@ -42,20 +43,16 @@ bool nr_pdcp_data_ind(const protocol_ctxt_t *const ctxt_pP,
                       const sdu_size_t sdu_buffer_size,
                       uint8_t *const sdu_buffer);
 
-void nr_pdcp_add_drbs(eNB_flag_t enb_flag,
-                      ue_id_t UEid,
-                      NR_DRB_ToAddModList_t *const drb2add_list,
-                      const nr_pdcp_entity_security_keys_and_algos_t *security_parameters);
-
 void nr_pdcp_add_srbs(eNB_flag_t enb_flag,
                       ue_id_t UEid,
                       NR_SRB_ToAddModList_t *const srb2add_list,
                       const nr_pdcp_entity_security_keys_and_algos_t *security_parameters);
 
-void add_drb(int is_gnb,
-             ue_id_t UEid,
-             struct NR_DRB_ToAddMod *s,
-             const nr_pdcp_entity_security_keys_and_algos_t *security_parameters);
+void nr_pdcp_add_drb(int is_gnb,
+                     const ue_id_t UEid,
+                     const NR_PDCP_Config_t *pdcp,
+                     const struct sdap_configuration_s *sdap,
+                     const nr_pdcp_entity_security_keys_and_algos_t *security_parameters);
 
 void nr_pdcp_remove_UE(ue_id_t ue_id);
 void nr_pdcp_reestablishment(ue_id_t ue_id,

openair2/RRC/NR/rrc_gNB_nsa.c

@@ -161,6 +161,28 @@ static NR_RadioBearerConfig_t *get_default_rbconfig(int eps_bearer_id,
   return rbconfig;
 }
 
+static void rrc_nsa_add_drb(const int ue_id,
+                            const NR_DRB_ToAddModList_t *addMod,
+                            const nr_pdcp_entity_security_keys_and_algos_t *sp)
+{
+  for (int i = 0; i < addMod->list.count; i++) {
+    NR_DRB_ToAddMod_t *drb = addMod->list.array[i];
+    DevAssert(drb->cnAssociation);
+    DevAssert(drb->cnAssociation->present != NR_DRB_ToAddMod__cnAssociation_PR_NOTHING);
+    DevAssert(drb->cnAssociation->present == NR_DRB_ToAddMod__cnAssociation_PR_eps_BearerIdentity);
+    // get SDAP config
+    sdap_config_t sdap = {0};
+    // EPC association
+    sdap.pdusession_id = drb->cnAssociation->choice.eps_BearerIdentity;
+    sdap.drb_id = drb->drb_Identity;
+    sdap.defaultDRB = true;
+    // add SDAP entity (terminated at gNB, since it's EPC)
+    nr_sdap_addmod_entity(GNB_FLAG_YES, ue_id, sdap);
+    // add PDCP entity
+    nr_pdcp_add_drb(GNB_FLAG_YES, ue_id, drb->pdcp_Config, &sdap, sp);
+  }
+}
+
 /* generate prototypes for the tree management functions (RB_INSERT used in rrc_add_nsa_user) */
 RB_PROTOTYPE(rrc_nr_ue_tree_s, rrc_gNB_ue_context_s, entries,
              rrc_gNB_compare_ue_rnti_id);
@@ -304,10 +326,7 @@ void rrc_add_nsa_user(gNB_RRC_INST *rrc, x2ap_ENDC_sgnb_addition_req_t *m, sctp_
   }
 
   DevAssert(UE->rb_config != NULL);
-  nr_pdcp_add_drbs(GNB_FLAG_YES,
-                   UE->rrc_ue_id,
-                   UE->rb_config->drb_ToAddModList,
-                   &security_parameters);
+  rrc_nsa_add_drb(UE->rrc_ue_id, UE->rb_config->drb_ToAddModList, &security_parameters);
 
   /* assumption: only a single bearer, see above */
   NR_DRB_ToAddModList_t *rb_list = UE->rb_config->drb_ToAddModList;

openair2/RRC/NR_UE/rrc_UE.c

@@ -599,6 +599,31 @@ static void nr_rrc_process_dedicatedNAS_MessageList(NR_UE_RRC_INST_t *rrc, NR_RR
   }
 }
 
+/** @brief Add bearer in PDCP/SDAP for 5GC association (SA) */
+static void rrc_ue_add_bearer(const int ue_id, const NR_DRB_ToAddMod_t *drb, const nr_pdcp_entity_security_keys_and_algos_t *sp)
+{
+  DevAssert(drb->cnAssociation);
+  DevAssert(drb->cnAssociation->present != NR_DRB_ToAddMod__cnAssociation_PR_NOTHING);
+  // get SDAP config
+  sdap_config_t sdap = {0};
+  if (drb->cnAssociation->present == NR_DRB_ToAddMod__cnAssociation_PR_eps_BearerIdentity) {
+    DevAssert(drb->cnAssociation->present == NR_DRB_ToAddMod__cnAssociation_PR_eps_BearerIdentity);
+
+    // EPC association
+    sdap.pdusession_id = drb->cnAssociation->choice.eps_BearerIdentity;
+    sdap.drb_id = drb->drb_Identity;
+    sdap.defaultDRB = true;
+  } else {
+    DevAssert(drb->cnAssociation->present == NR_DRB_ToAddMod__cnAssociation_PR_sdap_Config);
+    DevAssert(drb->cnAssociation->choice.sdap_Config);
+    sdap = nr_sdap_get_config(GNB_FLAG_NO, drb->cnAssociation->choice.sdap_Config, drb->drb_Identity);
+  }
+  // add SDAP entity
+  nr_sdap_addmod_entity(GNB_FLAG_NO, ue_id, sdap);
+  // add PDCP entity
+  nr_pdcp_add_drb(GNB_FLAG_NO, ue_id, drb->pdcp_Config, &sdap, sp);
+}
+
 /**
  * @brief add, modify and release SRBs and/or DRBs
  * @ref   3GPP TS 38.331
@@ -706,10 +731,7 @@ static void nr_rrc_ue_process_RadioBearerConfig(NR_UE_RRC_INST_t *ue_rrc, NR_Rad
           nr_reconfigure_sdap_entity(sdap_Config, ue_rrc->ue_id, sdap_Config->pdu_Session, DRB_id);
       } else {
         set_DRB_status(ue_rrc ,DRB_id, RB_ESTABLISHED);
-        add_drb(false,
-                ue_rrc->ue_id,
-                radioBearerConfig->drb_ToAddModList->list.array[cnt],
-                &security_up_parameters);
+        rrc_ue_add_bearer(ue_rrc->ue_id, radioBearerConfig->drb_ToAddModList->list.array[cnt], &security_up_parameters);
       }
     }
   } // drb_ToAddModList //

openair2/SDAP/nr_sdap/nr_sdap.c

@@ -47,7 +47,6 @@ static void reblock_tun_socket(int fd)
 bool sdap_data_req(protocol_ctxt_t *ctxt_p,
                    const ue_id_t ue_id,
                    const srb_flag_t srb_flag,
-                   const rb_id_t rb_id,
                    const mui_t mui,
                    const confirm_t confirm,
                    const sdu_size_t sdu_buffer_size,
@@ -69,7 +68,6 @@ bool sdap_data_req(protocol_ctxt_t *ctxt_p,
   bool ret = sdap_entity->tx_entity(sdap_entity,
                                     ctxt_p,
                                     srb_flag,
-                                    rb_id,
                                     mui,
                                     confirm,
                                     sdu_buffer_size,
@@ -82,7 +80,7 @@ bool sdap_data_req(protocol_ctxt_t *ctxt_p,
   return ret;
 }
 
-void sdap_data_ind(rb_id_t pdcp_entity,
+void sdap_data_ind(int pdcp_entity,
                    int is_gnb,
                    bool has_sdap_rx,
                    int pdusession_id,
@@ -100,7 +98,6 @@ void sdap_data_ind(rb_id_t pdcp_entity,
   sdap_entity->rx_entity(sdap_entity,
                          pdcp_entity,
                          is_gnb,
-                         has_sdap_rx,
                          pdusession_id,
                          ue_id,
                          buf,
@@ -116,8 +113,6 @@ static void *sdap_tun_read_thread(void *arg)
   int len;
   reblock_tun_socket(entity->pdusession_sock);
 
-  int rb_id = 1;
-
   while (!entity->stop_thread) {
     len = read(entity->pdusession_sock, &rx_buf, NL_MAX_PAYLOAD);
     if (len == -1) {
@@ -148,7 +143,6 @@ static void *sdap_tun_read_thread(void *arg)
     entity->tx_entity(entity,
                       &ctxt,
                       SRB_FLAG_NO,
-                      rb_id,
                       RLC_MUI_UNDEFINED,
                       RLC_SDU_CONFIRM_NO,
                       len,

openair2/SDAP/nr_sdap/nr_sdap.h

@@ -35,7 +35,6 @@
 bool sdap_data_req(protocol_ctxt_t *ctxt_p,
                    const ue_id_t ue_id,
                    const srb_flag_t srb_flag,
-                   const rb_id_t rb_id,
                    const mui_t mui,
                    const confirm_t confirm,
                    const sdu_size_t sdu_buffer_size,
@@ -53,7 +52,7 @@ bool sdap_data_req(protocol_ctxt_t *ctxt_p,
  * Uplink   - gNB
  * Downlink - nrUE
  */
-void sdap_data_ind(rb_id_t pdcp_entity,
+void sdap_data_ind(int pdcp_entity,
                    int is_gnb,
                    bool has_sdap_rx,
                    int pdusession_id,

openair2/SDAP/nr_sdap/nr_sdap_entity.h

@@ -38,7 +38,6 @@
 #define SDAP_HDR_LENGTH             (1)
 #define SDAP_MAX_QFI                (64)
 #define SDAP_MAP_RULE_EMPTY         (0)
-#define AVLBL_DRB                   (5)
 #define SDAP_NO_MAPPING_RULE        (0)
 #define SDAP_REFLECTIVE_MAPPING     (1)
 #define SDAP_RQI_HANDLING           (1)
@@ -69,17 +68,34 @@ typedef struct nr_sdap_ul_hdr_s {
   uint8_t DC:1;
 } __attribute__((packed)) nr_sdap_ul_hdr_t;
 
+typedef enum {
+  SDAP_UL_TX = (1 << 0),
+  SDAP_UL_RX = (1 << 1),
+  SDAP_DL_TX = (1 << 2),
+  SDAP_DL_RX = (1 << 3)
+} sdap_role_t;
+
 typedef struct qfi2drb_s {
-  rb_id_t drb_id;
-  bool    has_sdap_rx;
-  bool    has_sdap_tx;
+  int drb_id;
+  int entity_role;
 } qfi2drb_t;
 
-void nr_pdcp_submit_sdap_ctrl_pdu(ue_id_t ue_id, rb_id_t sdap_ctrl_pdu_drb, nr_sdap_ul_hdr_t ctrl_pdu);
+void nr_pdcp_submit_sdap_ctrl_pdu(ue_id_t ue_id, int sdap_ctrl_pdu_drb, nr_sdap_ul_hdr_t ctrl_pdu);
+
+typedef struct sdap_configuration_s {
+  int pdusession_id;
+  int drb_id;
+  int role;
+  bool defaultDRB;
+  NR_QFI_t mappedQFIs2Add[SDAP_MAX_QFI];
+  uint8_t mappedQFIs2AddCount;
+  NR_QFI_t mappedQFIs2Release[SDAP_MAX_QFI];
+  uint8_t mappedQFIs2ReleaseCount;
+} sdap_config_t;
 
 typedef struct nr_sdap_entity_s {
   ue_id_t ue_id;
-  rb_id_t default_drb;
+  int default_drb;
   /// sdap_tun_read_thread needs to know if we are gNB/UE, so for noS1 mode,
   /// store which one we are
   bool is_gnb;
@@ -91,18 +107,21 @@ typedef struct nr_sdap_entity_s {
 
   qfi2drb_t qfi2drb_table[SDAP_MAX_QFI];
 
-  void (*qfi2drb_map_update)(struct nr_sdap_entity_s *entity, uint8_t qfi, rb_id_t drb, bool has_sdap_rx, bool has_sdap_tx);
-  void (*qfi2drb_map_delete)(struct nr_sdap_entity_s *entity, uint8_t qfi);
-  rb_id_t (*qfi2drb_map)(struct nr_sdap_entity_s *entity, uint8_t qfi);
+  void (*qfi2drb_map_update)(struct nr_sdap_entity_s *entity, const sdap_config_t *sdap);
+  void (*qfi2drb_map_delete)(struct nr_sdap_entity_s *entity, const uint8_t qfi);
+  void (*qfi2drb_map_add)(struct nr_sdap_entity_s *entity,
+                          const uint8_t qfi,
+                          const uint8_t drb_id,
+                          const uint8_t role);
+  int (*qfi2drb_map)(struct nr_sdap_entity_s *entity, uint8_t qfi);
 
   nr_sdap_ul_hdr_t (*sdap_construct_ctrl_pdu)(uint8_t qfi);
-  rb_id_t (*sdap_map_ctrl_pdu)(struct nr_sdap_entity_s *entity, rb_id_t pdcp_entity, int map_type, uint8_t dl_qfi);
-  void (*sdap_submit_ctrl_pdu)(ue_id_t ue_id, rb_id_t sdap_ctrl_pdu_drb, nr_sdap_ul_hdr_t ctrl_pdu);
+  int (*sdap_map_ctrl_pdu)(struct nr_sdap_entity_s *entity, int map_type, uint8_t dl_qfi);
+  void (*sdap_submit_ctrl_pdu)(ue_id_t ue_id, int sdap_ctrl_pdu_drb, nr_sdap_ul_hdr_t ctrl_pdu);
 
   bool (*tx_entity)(struct nr_sdap_entity_s *entity,
                     protocol_ctxt_t *ctxt_p,
                     const srb_flag_t srb_flag,
-                    const rb_id_t rb_id,
                     const mui_t mui,
                     const confirm_t confirm,
                     const sdu_size_t sdu_buffer_size,
@@ -114,9 +133,8 @@ typedef struct nr_sdap_entity_s {
                     const bool rqi);
 
   void (*rx_entity)(struct nr_sdap_entity_s *entity,
-                    rb_id_t pdcp_entity,
+                    int pdcp_entity,
                     int is_gnb,
-                    bool has_sdap_rx,
                     int pdusession_id,
                     ue_id_t ue_id,
                     char *buf,
@@ -126,23 +144,6 @@ typedef struct nr_sdap_entity_s {
   struct nr_sdap_entity_s *next_entity;
 } nr_sdap_entity_t;
 
-/* QFI to DRB Mapping Related Function */
-void nr_sdap_qfi2drb_map_update(nr_sdap_entity_t *entity, uint8_t qfi, rb_id_t drb, bool has_sdap_rx, bool has_sdap_tx);
-
-/* QFI to DRB Mapping Related Function */
-void nr_sdap_qfi2drb_map_del(nr_sdap_entity_t *entity, uint8_t qfi);
-
-/*
- * TS 37.324
- * 4.4 Functions
- * Mapping between a QoS flow and a DRB for both DL and UL.
- *
- * 5.2.1 Uplink
- * If there is no stored QoS flow to DRB mapping rule for the QoS flow as specified in the subclause 5.3, map the SDAP SDU to the default DRB
- * else, map the SDAP SDU to the DRB according to the stored QoS flow to DRB mapping rule.
- */
-rb_id_t nr_sdap_qfi2drb_map(nr_sdap_entity_t *entity, uint8_t qfi);
-
 /*
  * TS 37.324 5.3 QoS flow to DRB Mapping 
  * construct an end-marker control PDU, as specified in the subclause 6.2.3, for the QoS flow;
@@ -155,33 +156,24 @@ nr_sdap_ul_hdr_t nr_sdap_construct_ctrl_pdu(uint8_t qfi);
  * 1.) default DRB or 
  * 2.) DRB according to the stored QoS flow to DRB mapping rule
  */
-rb_id_t nr_sdap_map_ctrl_pdu(nr_sdap_entity_t *entity, rb_id_t pdcp_entity, int map_type, uint8_t dl_qfi);
+int nr_sdap_map_ctrl_pdu(nr_sdap_entity_t *entity, int map_type, uint8_t dl_qfi);
 
 /*
  * TS 37.324 5.3 QoS flow to DRB Mapping 
  * Submit the end-marker control PDU to the lower layer.
  */
-void nr_sdap_submit_ctrl_pdu(ue_id_t ue_id, rb_id_t sdap_ctrl_pdu_drb, nr_sdap_ul_hdr_t ctrl_pdu);
-
-/*
- * TS 37.324 4.4 5.1.1 SDAP entity establishment
- * Establish an SDAP entity.
- */
-nr_sdap_entity_t *new_nr_sdap_entity(int is_gnb,
-                                     bool has_sdap_rx,
-                                     bool has_sdap_tx,
-                                     ue_id_t ue_id,
-                                     int pdusession_id,
-                                     bool is_defaultDRB,
-                                     uint8_t default_DRB,
-                                     NR_QFI_t *mapped_qfi_2_add,
-                                     uint8_t mappedQFIs2AddCount);
+void nr_sdap_submit_ctrl_pdu(ue_id_t ue_id, int sdap_ctrl_pdu_drb, nr_sdap_ul_hdr_t ctrl_pdu);
 
 /* Entity Handling Related Functions */
 nr_sdap_entity_t *nr_sdap_get_entity(ue_id_t ue_id, int pdusession_id);
 
+sdap_config_t nr_sdap_get_config(const int is_gnb, const NR_SDAP_Config_t *sdap_Config, const int drb_id);
+
 void nr_sdap_release_drb(ue_id_t ue_id, int drb_id, int pdusession_id);
 
+/** @brief Add or modify an SDAP entity based on whether it already exists */
+void nr_sdap_addmod_entity(const int is_gnb, const ue_id_t ue_id, const sdap_config_t sdap);
+
 /**
  * @brief Function to delete a single SDAP Entity based on the ue_id and pdusession_id.
  * @note  1. SDAP entities may have the same ue_id.
@@ -200,20 +192,6 @@ bool nr_sdap_delete_entity(ue_id_t ue_id, int pdusession_id);
  */
 bool nr_sdap_delete_ue_entities(ue_id_t ue_id);
 
-/**
- * @brief indicates whether it is a receiving SDAP entity
- *        i.e. for UE, header for DL data is present
- *             for gNB, header for UL data is present
- */
-bool is_sdap_rx(bool is_gnb, NR_SDAP_Config_t *sdap_config);
-
-/**
- * @brief indicates whether it is a transmitting SDAP entity
- *        i.e. for UE, header for UL data is present
- *             for gNB, header for DL data is present
- */
-bool is_sdap_tx(bool is_gnb, NR_SDAP_Config_t *sdap_config);
-
 /**
  * @brief               Run the SDAP reconfiguration for the DRB
  * @param[in] ue_id     Unique identifier for the User Equipment. ID Range [0, 65536].

openair3/ocp-gtpu/gtp_itf.cpp

@@ -1244,7 +1244,6 @@ static int Gtpv1uHandleGpdu(int h, uint8_t *msgBuf, uint32_t msgBufLen, const st
       if (!uedata.callBackSDAP(&ctxt,
                                        uedata.ue_id,
                                        srb_flag,
-                                       rb_id,
                                        mui,
                                        confirm,
                                        sdu_buffer_size,

openair3/ocp-gtpu/gtp_itf.h

@@ -49,7 +49,6 @@ typedef struct gtpv1u_gnb_delete_tunnel_req_s gtpv1u_gnb_delete_tunnel_req_t;
   typedef bool (*gtpCallbackSDAP)(protocol_ctxt_t  *ctxt_pP,
                                   const ue_id_t        ue_id,
                                   const srb_flag_t     srb_flagP,
-                                  const rb_id_t        rb_idP,
                                   const mui_t          muiP,
                                   const confirm_t      confirmP,
                                   const sdu_size_t     sdu_buffer_sizeP,

tests/nr-cuup/nr-cuup-load-test.c

@@ -165,7 +165,6 @@ static struct ue_stat {
 static bool recv_ng(protocol_ctxt_t *ctxt,
                     const ue_id_t ue_id,
                     const srb_flag_t flag,
-                    const rb_id_t rb,
                     const mui_t mui,
                     const confirm_t confirm,
                     const sdu_size_t size,