cu_cp,rrc: refactor rrc procedure timeouts

FabianEckermann · codebot · commit 8776670489b5 · 2025-09-08T11:03:42.000Z
diff --git a/apps/units/o_cu_cp/cu_cp/cu_cp_config_translators.cpp b/apps/units/o_cu_cp/cu_cp/cu_cp_config_translators.cpp
@@ -375,7 +375,7 @@ srs_cu_cp::cu_cp_configuration srsran::generate_cu_cp_config(const cu_cp_unit_co
 #endif // SRSRAN_HAS_ENTERPRISE
 
   out_cfg.rrc.force_reestablishment_fallback = cu_cfg.rrc_config.force_reestablishment_fallback;
-  out_cfg.rrc.rrc_procedure_timeout_ms       = std::chrono::milliseconds{cu_cfg.rrc_config.rrc_procedure_timeout_ms};
+  out_cfg.rrc.rrc_procedure_guard_time_ms    = std::chrono::milliseconds{cu_cfg.rrc_config.rrc_procedure_guard_time_ms};
 
   out_cfg.bearers.drb_config = generate_cu_cp_qos_config(cu_cfg);
 
diff --git a/apps/units/o_cu_cp/cu_cp/cu_cp_unit_config.h b/apps/units/o_cu_cp/cu_cp/cu_cp_unit_config.h
@@ -133,9 +133,8 @@ struct cu_cp_unit_mobility_config {
 /// RRC specific configuration parameters.
 struct cu_cp_unit_rrc_config {
   bool force_reestablishment_fallback = false;
-  /// Timeout for RRC procedures (2 * default SRB maxRetxThreshold * t-PollRetransmit = 2 * 8 * 45ms = 720ms, see
-  /// TS 38.331 Sec 9.2.1).
-  unsigned rrc_procedure_timeout_ms = 720;
+  /// Guard time for RRC procedures.
+  unsigned rrc_procedure_guard_time_ms = 500;
 };
 
 /// Security configuration parameters.
diff --git a/apps/units/o_cu_cp/cu_cp/cu_cp_unit_config_cli11_schema.cpp b/apps/units/o_cu_cp/cu_cp/cu_cp_unit_config_cli11_schema.cpp
@@ -341,12 +341,10 @@ static void configure_cli11_rrc_args(CLI::App& app, cu_cp_unit_rrc_config& confi
              "Force RRC re-establishment fallback to RRC setup")
       ->capture_default_str();
 
-  add_option(
-      app,
-      "--rrc_procedure_timeout_ms",
-      config.rrc_procedure_timeout_ms,
-      "Timeout in ms used for RRC message exchange with UE. It needs to suit the expected communication delay and "
-      "account for potential retransmissions UE processing delays, SR delays, etc.")
+  add_option(app,
+             "--rrc_procedure_guard_time_ms",
+             config.rrc_procedure_guard_time_ms,
+             "Guard time in ms used for RRC message exchange with UE. This is added to the RRC procedure timeout.")
       ->capture_default_str();
 }
 
diff --git a/apps/units/o_cu_cp/cu_cp/cu_cp_unit_config_yaml_writer.cpp b/apps/units/o_cu_cp/cu_cp/cu_cp_unit_config_yaml_writer.cpp
@@ -205,7 +205,7 @@ static YAML::Node build_cu_cp_rrc_section(const cu_cp_unit_rrc_config& config)
   YAML::Node node;
 
   node["force_reestablishment_fallback"] = config.force_reestablishment_fallback;
-  node["rrc_procedure_timeout_ms"]       = config.rrc_procedure_timeout_ms;
+  node["rrc_procedure_guard_time_ms"]    = config.rrc_procedure_guard_time_ms;
 
   return node;
 }
diff --git a/configs/geo_ntn.yml b/configs/geo_ntn.yml
@@ -25,5 +25,5 @@ cell_cfg:
     max_msg3_harq_retx: 0
 
 cu_cp:
-  rrc: # sets the RRC timeout to 12.8 seconds to allow for the larger channel delay
-    rrc_procedure_timeout_ms: 12800
+  rrc: # sets the RRC guard time to 12.8 seconds to allow for the larger channel delay
+    rrc_procedure_guard_time_ms: 12800
diff --git a/include/srsran/cu_cp/cu_cp_configuration.h b/include/srsran/cu_cp/cu_cp_configuration.h
@@ -93,8 +93,8 @@ struct cu_cp_configuration {
   struct rrc_params {
     /// Force re-establishment fallback.
     bool force_reestablishment_fallback = false;
-    /// Timeout for RRC procedures.
-    std::chrono::milliseconds rrc_procedure_timeout_ms{360};
+    /// Guard time for RRC procedures.
+    std::chrono::milliseconds rrc_procedure_guard_time_ms{500};
     /// Version of the RRC.
     unsigned rrc_version = 2;
   };
diff --git a/include/srsran/rrc/rrc_config.h b/include/srsran/rrc/rrc_config.h
@@ -33,8 +33,8 @@ struct rrc_cfg_t {
   security::preferred_ciphering_algorithms enc_algo_pref_list{security::ciphering_algorithm::nea0};
   /// Force re-establishment fallback.
   bool force_reestablishment_fallback = false;
-  /// Timeout for RRC procedures.
-  std::chrono::milliseconds rrc_procedure_timeout_ms{360};
+  /// Guard time for RRC procedures.
+  std::chrono::milliseconds rrc_procedure_guard_time_ms{500};
 };
 
 } // namespace srs_cu_cp
diff --git a/include/srsran/rrc/rrc_ue_config.h b/include/srsran/rrc/rrc_ue_config.h
@@ -28,10 +28,8 @@ struct rrc_ue_cfg_t {
   srb_pdcp_config              srb1_pdcp_cfg;
   std::vector<rrc_meas_timing> meas_timings;
   bool                         force_reestablishment_fallback = false;
-  /// \brief Timeout used for RRC message exchange with UE. It needs to suit the expected communication delay and
-  /// account for potential retransmissions (HARQ and RLC), UE processing delays (see Sec 12 in TS 38.331), SR delays,
-  /// etc.
-  std::chrono::milliseconds rrc_procedure_timeout_ms{360};
+  /// \brief Guard time used for RRC message exchange with UE.
+  std::chrono::milliseconds rrc_procedure_guard_time_ms{500};
 };
 
 } // namespace srs_cu_cp
diff --git a/lib/cu_cp/du_processor/du_processor_impl.cpp b/lib/cu_cp/du_processor/du_processor_impl.cpp
@@ -24,7 +24,7 @@ static rrc_cfg_t create_rrc_config(const cu_cp_configuration& cu_cp_cfg)
   rrc_cfg_t rrc_cfg;
   rrc_cfg.gnb_id                         = cu_cp_cfg.node.gnb_id;
   rrc_cfg.force_reestablishment_fallback = cu_cp_cfg.rrc.force_reestablishment_fallback;
-  rrc_cfg.rrc_procedure_timeout_ms       = cu_cp_cfg.rrc.rrc_procedure_timeout_ms;
+  rrc_cfg.rrc_procedure_guard_time_ms    = cu_cp_cfg.rrc.rrc_procedure_guard_time_ms;
   rrc_cfg.int_algo_pref_list             = cu_cp_cfg.security.int_algo_pref_list;
   rrc_cfg.enc_algo_pref_list             = cu_cp_cfg.security.enc_algo_pref_list;
   rrc_cfg.srb2_cfg                       = cu_cp_cfg.bearers.srb2_cfg;
diff --git a/lib/rrc/rrc_du_impl.cpp b/lib/rrc/rrc_du_impl.cpp
@@ -138,12 +138,13 @@ rrc_ue_interface* rrc_du_impl::add_ue(const rrc_ue_creation_message& msg)
   ue_index_t   ue_index                 = msg.ue_index;
   rrc_ue_cfg_t ue_cfg                   = {};
   ue_cfg.force_reestablishment_fallback = cfg.force_reestablishment_fallback;
-  ue_cfg.rrc_procedure_timeout_ms       = cfg.rrc_procedure_timeout_ms;
+  ue_cfg.rrc_procedure_guard_time_ms    = cfg.rrc_procedure_guard_time_ms;
   ue_cfg.meas_timings                   = cell_info_db.at(msg.cell.cgi.nci).meas_timings;
 
   // Copy RRC cell and add SSB ARFCN.
   rrc_cell_context rrc_cell = msg.cell;
   rrc_cell.ssb_arfcn        = ue_cfg.meas_timings.front().freq_and_timing.value().carrier_freq;
+  rrc_cell.timers           = cell_info_db.at(msg.cell.cgi.nci).timers;
 
   // Add RRC UE to RRC DU adapter.
   rrc_ue_rrc_du_adapters.emplace(ue_index, rrc_ue_rrc_du_adapter{get_rrc_du_connection_event_handler()});
diff --git a/lib/rrc/ue/procedures/rrc_reconfiguration_procedure.cpp b/lib/rrc/ue/procedures/rrc_reconfiguration_procedure.cpp
@@ -29,6 +29,8 @@ rrc_reconfiguration_procedure::rrc_reconfiguration_procedure(rrc_ue_context_t&
   srb_notifier(srb_notifier_),
   logger(logger_)
 {
+  procedure_timeout =
+      context.cell.timers.t311 + std::chrono::milliseconds(500) + context.cfg.rrc_procedure_guard_time_ms;
 }
 
 void rrc_reconfiguration_procedure::operator()(coro_context<async_task<bool>>& ctx)
@@ -42,8 +44,7 @@ void rrc_reconfiguration_procedure::operator()(coro_context<async_task<bool>>& c
 
   logger.log_debug("\"{}\" initialized", name());
   // create new transaction for RRC Reconfiguration procedure
-  transaction =
-      event_mng.transactions.create_transaction(std::chrono::milliseconds(context.cfg.rrc_procedure_timeout_ms));
+  transaction = event_mng.transactions.create_transaction(procedure_timeout);
 
   if (args.radio_bearer_cfg.has_value()) {
     for (const rrc_srb_to_add_mod& srb_to_add_mod : args.radio_bearer_cfg->srb_to_add_mod_list) {
@@ -61,7 +62,7 @@ void rrc_reconfiguration_procedure::operator()(coro_context<async_task<bool>>& c
     logger.log_debug("\"{}\" finished successfully", name());
     procedure_result = true;
   } else {
-    logger.log_warning("\"{}\" timed out after {}ms", name(), context.cfg.rrc_procedure_timeout_ms.count());
+    logger.log_warning("\"{}\" timed out after {}ms", name(), procedure_timeout.count());
   }
 
   CORO_RETURN(procedure_result);
diff --git a/lib/rrc/ue/procedures/rrc_reconfiguration_procedure.h b/lib/rrc/ue/procedures/rrc_reconfiguration_procedure.h
@@ -16,6 +16,7 @@
 #include "srsran/rrc/rrc_ue.h"
 #include "srsran/support/async/async_task.h"
 #include "srsran/support/async/eager_async_task.h"
+#include <chrono>
 
 namespace srsran {
 namespace srs_cu_cp {
@@ -48,6 +49,7 @@ class rrc_reconfiguration_procedure
   rrc_ue_control_message_handler&       srb_notifier; // For creating SRBs
   rrc_ue_logger&                        logger;
 
+  std::chrono::milliseconds     procedure_timeout{0};
   rrc_transaction               transaction;
   eager_async_task<rrc_outcome> task;
 
diff --git a/lib/rrc/ue/procedures/rrc_reestablishment_procedure.cpp b/lib/rrc/ue/procedures/rrc_reestablishment_procedure.cpp
@@ -45,6 +45,8 @@ rrc_reestablishment_procedure::rrc_reestablishment_procedure(
   event_mng(event_mng_),
   logger(logger_)
 {
+  procedure_timeout =
+      context.cell.timers.t311 + std::chrono::milliseconds(500) + context.cfg.rrc_procedure_guard_time_ms;
 }
 
 void rrc_reestablishment_procedure::operator()(coro_context<async_task<void>>& ctx)
@@ -84,8 +86,7 @@ void rrc_reestablishment_procedure::operator()(coro_context<async_task<void>>& c
   create_srb1();
 
   // Create new transaction for RRC Reestablishment.
-  transaction =
-      event_mng.transactions.create_transaction(std::chrono::milliseconds(context.cfg.rrc_procedure_timeout_ms));
+  transaction = event_mng.transactions.create_transaction(procedure_timeout);
 
   // Send RRC Reestablishment to UE.
   send_rrc_reestablishment();
@@ -122,10 +123,8 @@ void rrc_reestablishment_procedure::operator()(coro_context<async_task<void>>& c
     }
 
   } else {
-    logger.log_warning("\"{}\" for old_ue={} timed out after {}ms",
-                       name(),
-                       old_ue_reest_context.ue_index,
-                       context.cfg.rrc_procedure_timeout_ms.count());
+    logger.log_warning(
+        "\"{}\" for old_ue={} timed out after {}ms", name(), old_ue_reest_context.ue_index, procedure_timeout.count());
     logger.log_debug("\"{}\" for old_ue={} failed", name(), old_ue_reest_context.ue_index);
   }
 
diff --git a/lib/rrc/ue/procedures/rrc_reestablishment_procedure.h b/lib/rrc/ue/procedures/rrc_reestablishment_procedure.h
@@ -16,6 +16,7 @@
 #include "srsran/rrc/rrc_ue.h"
 #include "srsran/support/async/async_task.h"
 #include "srsran/support/async/eager_async_task.h"
+#include <chrono>
 
 namespace srsran {
 namespace srs_cu_cp {
@@ -77,6 +78,7 @@ class rrc_reestablishment_procedure
   rrc_ue_logger&                           logger;
 
   const asn1::rrc_nr::pdcp_cfg_s          srb1_pdcp_cfg;
+  std::chrono::milliseconds               procedure_timeout{0};
   rrc_transaction                         transaction;
   eager_async_task<rrc_outcome>           task;
   rrc_ue_reestablishment_context_response old_ue_reest_context;
diff --git a/lib/rrc/ue/procedures/rrc_setup_procedure.cpp b/lib/rrc/ue/procedures/rrc_setup_procedure.cpp
@@ -37,6 +37,8 @@ rrc_setup_procedure::rrc_setup_procedure(rrc_ue_context_t&               context
   is_reestablishment_fallback(is_reestablishment_fallback_),
   logger(logger_)
 {
+  procedure_timeout =
+      context.cell.timers.t300 + std::chrono::milliseconds(500) + context.cfg.rrc_procedure_guard_time_ms;
 }
 
 void rrc_setup_procedure::operator()(coro_context<async_task<void>>& ctx)
@@ -47,8 +49,7 @@ void rrc_setup_procedure::operator()(coro_context<async_task<void>>& ctx)
   create_srb1();
 
   // create new transaction for RRCSetup
-  transaction =
-      event_mng.transactions.create_transaction(std::chrono::milliseconds(context.cfg.rrc_procedure_timeout_ms));
+  transaction = event_mng.transactions.create_transaction(procedure_timeout);
 
   // send RRC setup to UE
   send_rrc_setup();
@@ -58,7 +59,7 @@ void rrc_setup_procedure::operator()(coro_context<async_task<void>>& ctx)
 
   if (!transaction.has_response()) {
     if (transaction.failure_cause() == protocol_transaction_failure::timeout) {
-      logger.log_warning("\"{}\" timed out after {}ms", name(), context.cfg.rrc_procedure_timeout_ms.count());
+      logger.log_warning("\"{}\" timed out after {}ms", name(), procedure_timeout.count());
       rrc_ue.on_ue_release_required(cause_protocol_t::unspecified);
     } else {
       logger.log_warning("\"{}\" cancelled", name());
diff --git a/lib/rrc/ue/procedures/rrc_setup_procedure.h b/lib/rrc/ue/procedures/rrc_setup_procedure.h
@@ -18,6 +18,7 @@
 #include "srsran/rrc/rrc_ue.h"
 #include "srsran/support/async/async_task.h"
 #include "srsran/support/async/eager_async_task.h"
+#include <chrono>
 
 namespace srsran {
 namespace srs_cu_cp {
@@ -92,6 +93,7 @@ class rrc_setup_procedure
   bool                            is_reestablishment_fallback = false;
   rrc_ue_logger&                  logger;
 
+  std::chrono::milliseconds     procedure_timeout{0};
   rrc_transaction               transaction;
   eager_async_task<rrc_outcome> task;
 };
diff --git a/lib/rrc/ue/procedures/rrc_ue_capability_transfer_procedure.cpp b/lib/rrc/ue/procedures/rrc_ue_capability_transfer_procedure.cpp
@@ -22,6 +22,7 @@ rrc_ue_capability_transfer_procedure::rrc_ue_capability_transfer_procedure(
     rrc_ue_logger&                              logger_) :
   context(context_), rrc_ue(rrc_ue_notifier_), event_mng(event_mng_), logger(logger_)
 {
+  procedure_timeout = std::chrono::milliseconds(500) + context.cfg.rrc_procedure_guard_time_ms;
 }
 
 void rrc_ue_capability_transfer_procedure::operator()(coro_context<async_task<bool>>& ctx)
@@ -35,8 +36,7 @@ void rrc_ue_capability_transfer_procedure::operator()(coro_context<async_task<bo
 
   logger.log_debug("\"{}\" initialized", name());
   // create new transaction for RRCUeCapabilityEnquiry
-  transaction =
-      event_mng.transactions.create_transaction(std::chrono::milliseconds(context.cfg.rrc_procedure_timeout_ms));
+  transaction = event_mng.transactions.create_transaction(procedure_timeout);
 
   // send RRC UE Capability Enquiry to UE
   send_rrc_ue_capability_enquiry();
@@ -71,7 +71,7 @@ void rrc_ue_capability_transfer_procedure::operator()(coro_context<async_task<bo
     }
     procedure_result = context.capabilities_list.has_value();
   } else {
-    logger.log_warning("\"{}\" timed out after {}ms", name(), context.cfg.rrc_procedure_timeout_ms.count());
+    logger.log_warning("\"{}\" timed out after {}ms", name(), procedure_timeout.count());
   }
 
   logger.log_debug("\"{}\" finalized", name());
diff --git a/lib/rrc/ue/procedures/rrc_ue_capability_transfer_procedure.h b/lib/rrc/ue/procedures/rrc_ue_capability_transfer_procedure.h
@@ -18,6 +18,7 @@
 #include "srsran/rrc/rrc_ue.h"
 #include "srsran/support/async/async_task.h"
 #include "srsran/support/async/eager_async_task.h"
+#include <chrono>
 
 namespace srsran {
 namespace srs_cu_cp {
@@ -45,6 +46,7 @@ class rrc_ue_capability_transfer_procedure
   rrc_ue_event_manager&                       event_mng; // event manager for the RRC UE entity
   rrc_ue_logger&                              logger;
 
+  std::chrono::milliseconds     procedure_timeout{0};
   rrc_transaction               transaction;
   eager_async_task<rrc_outcome> task;
 
diff --git a/lib/rrc/ue/rrc_ue_impl.cpp b/lib/rrc/ue/rrc_ue_impl.cpp
@@ -43,7 +43,6 @@ rrc_ue_impl::rrc_ue_impl(rrc_pdu_f1ap_notifier&                 f1ap_pdu_notifie
   event_mng(std::make_unique<rrc_ue_event_manager>(cu_cp_ue_notifier.get_timer_factory()))
 {
   srsran_assert(context.cell.bands.empty() == false, "Band must be present in RRC cell configuration.");
-  srsran_assert(context.cfg.rrc_procedure_timeout_ms.count() > 0, "RRC procedure timeout cannot be zero.");
 
   // Update security context and keys
   if (rrc_context.has_value()) {
diff --git a/lib/rrc/ue/rrc_ue_message_handlers.cpp b/lib/rrc/ue/rrc_ue_message_handlers.cpp
@@ -21,6 +21,7 @@
 #include "srsran/asn1/rrc_nr/meas_cfg.h"
 #include "srsran/asn1/rrc_nr/ul_ccch_msg.h"
 #include "srsran/ran/rb_id.h"
+#include <chrono>
 
 using namespace srsran;
 using namespace srs_cu_cp;
@@ -319,7 +320,7 @@ rrc_ue_security_mode_command_context rrc_ue_impl::get_security_mode_command_cont
 async_task<bool> rrc_ue_impl::handle_security_mode_complete_expected(uint8_t transaction_id)
 {
   return launch_async([this,
-                       timeout_ms = context.cfg.rrc_procedure_timeout_ms,
+                       timeout_ms = std::chrono::milliseconds{500} + context.cfg.rrc_procedure_guard_time_ms,
                        transaction_id,
                        transaction = rrc_transaction{}](coro_context<async_task<bool>>& ctx) mutable {
     CORO_BEGIN(ctx);
diff --git a/tests/e2e/tests/steps/configuration.py b/tests/e2e/tests/steps/configuration.py
@@ -33,15 +33,15 @@ def configure_ntn_parameters(
     if ntn_config.scenario_type == NtnScenarioType.GEO:
         retina_data.test_config["gnb"]["parameters"]["cu_cp_inactivity_timer"] = 120
         retina_data.test_config["gnb"]["parameters"]["request_pdu_session_timeout"] = 12
-        retina_data.test_config["gnb"]["parameters"]["rrc_procedure_timeout_ms"] = 12800
+        retina_data.test_config["gnb"]["parameters"]["rrc_procedure_guard_time_ms"] = 12800
     elif ntn_config.scenario_type == NtnScenarioType.MEO:
         retina_data.test_config["gnb"]["parameters"]["cu_cp_inactivity_timer"] = 90
         retina_data.test_config["gnb"]["parameters"]["request_pdu_session_timeout"] = 9
-        retina_data.test_config["gnb"]["parameters"]["rrc_procedure_timeout_ms"] = 12800
+        retina_data.test_config["gnb"]["parameters"]["rrc_procedure_guard_time_ms"] = 12800
     else:  # LEO
         retina_data.test_config["gnb"]["parameters"]["cu_cp_inactivity_timer"] = 60
         retina_data.test_config["gnb"]["parameters"]["request_pdu_session_timeout"] = 6
-        retina_data.test_config["gnb"]["parameters"]["rrc_procedure_timeout_ms"] = 10000
+        retina_data.test_config["gnb"]["parameters"]["rrc_procedure_guard_time_ms"] = 10000
 
     # DU NTN parameters.
     retina_data.test_config["gnb"]["parameters"]["sib19"] = {}
diff --git a/tests/e2e/tests/viavi/test_declaration.yml b/tests/e2e/tests/viavi/test_declaration.yml
@@ -39,7 +39,7 @@ tests:
           enable_ru: true
       cu_cp:
         rrc:
-          rrc_procedure_timeout_ms: 2000
+          rrc_procedure_guard_time_ms: 2000
       expert_execution:
         queues:
           du_ue_data_executor_queue_size: 16384
diff --git a/tests/unittests/cu_cp/CMakeLists.txt b/tests/unittests/cu_cp/CMakeLists.txt
@@ -27,7 +27,7 @@ add_library(cu_cp_test_helpers
         du_processor_test_messages.cpp
         test_helpers.cpp)
 target_include_directories(cu_cp_test_helpers PRIVATE ${CMAKE_SOURCE_DIR})
-target_link_libraries(cu_cp_test_helpers srsran_cu_cp srsran_support srslog f1ap_test_helpers e1ap_test_helpers f1ap_asn1 ngap_asn1 e1ap_asn1 srsran_e2)
+target_link_libraries(cu_cp_test_helpers srsran_cu_cp srsran_support srslog f1ap_test_helpers e1ap_test_helpers rrc_ue_test_helpers f1ap_asn1 ngap_asn1 e1ap_asn1 srsran_e2)
 
 
 add_executable(cu_cp_test
diff --git a/tests/unittests/cu_cp/cu_cp_initial_context_setup_test.cpp b/tests/unittests/cu_cp/cu_cp_initial_context_setup_test.cpp
@@ -273,6 +273,8 @@ class cu_cp_initial_context_setup_test : public cu_cp_test_environment, public :
   ngap_message ngap_pdu;
   f1ap_message f1ap_pdu;
   e1ap_message e1ap_pdu;
+
+  std::chrono::milliseconds rrc_procedure_extra_time{500};
 };
 
 TEST_F(cu_cp_initial_context_setup_test, when_ue_context_setup_fails_then_initial_context_setup_fails)
@@ -319,7 +321,9 @@ TEST_F(cu_cp_initial_context_setup_test, when_ue_capability_enquiry_fails_then_i
 
   // Fail UE Capability Enquiry (UE doesn't respond)
   ASSERT_FALSE(tick_until(
-      std::chrono::milliseconds(this->get_cu_cp_cfg().rrc.rrc_procedure_timeout_ms), [&]() { return false; }, false));
+      rrc_procedure_extra_time + this->get_cu_cp_cfg().rrc.rrc_procedure_guard_time_ms,
+      [&]() { return false; },
+      false));
 
   // Wait for NGAP Initial Context Setup Failure
   ASSERT_TRUE(await_initial_context_setup_failure());
diff --git a/tests/unittests/cu_cp/cu_cp_pdu_session_resource_modify_test.cpp b/tests/unittests/cu_cp/cu_cp_pdu_session_resource_modify_test.cpp
@@ -279,11 +279,15 @@ class cu_cp_pdu_session_resource_modify_test : public cu_cp_test_environment, pu
     return true;
   }
 
+  std::chrono::milliseconds rrc_procedure_extra_time{500};
+  std::chrono::milliseconds t310{1000};
+  std::chrono::milliseconds t311{3000};
+
   [[nodiscard]] bool timeout_rrc_reconfiguration_and_await_pdu_session_modify_response()
   {
     // Fail RRC Reconfiguration (UE doesn't respond) and wait for PDU Session Resource Setup Response
     if (tick_until(
-            std::chrono::milliseconds(this->get_cu_cp_cfg().rrc.rrc_procedure_timeout_ms),
+            t310 + t311 + rrc_procedure_extra_time + this->get_cu_cp_cfg().rrc.rrc_procedure_guard_time_ms,
             [&]() { return false; },
             false)) {
       return false;
diff --git a/tests/unittests/cu_cp/cu_cp_pdu_session_resource_setup_test.cpp b/tests/unittests/cu_cp/cu_cp_pdu_session_resource_setup_test.cpp
diff --git a/tests/unittests/cu_cp/cu_cp_reestablishment_test.cpp b/tests/unittests/cu_cp/cu_cp_reestablishment_test.cpp
diff --git a/tests/unittests/cu_cp/cu_cp_test_environment.cpp b/tests/unittests/cu_cp/cu_cp_test_environment.cpp
diff --git a/tests/unittests/rrc/rrc_ue_test_helpers.h b/tests/unittests/rrc/rrc_ue_test_helpers.h

Original file line number	Diff line number	Diff line change
`@@ -205,7 +205,7 @@ static YAML::Node build_cu_cp_rrc_section(const cu_cp_unit_rrc_config& config)`
`205`	`205`	`YAML::Node node;`
`206`	`206`
`207`	`207`	`node["force_reestablishment_fallback"] = config.force_reestablishment_fallback;`
`208`		`- node["rrc_procedure_timeout_ms"] = config.rrc_procedure_timeout_ms;`
	`208`	`+ node["rrc_procedure_guard_time_ms"] = config.rrc_procedure_guard_time_ms;`
`209`	`209`
`210`	`210`	`return node;`
`211`	`211`	`}`