gtpu: add warn on drop config

Author: alvasMan

apps/gnb/gnb_appconfig.h

@@ -711,6 +711,7 @@ struct cu_cp_appconfig {
 struct cu_up_appconfig {
   unsigned gtpu_queue_size          = 2048;
   unsigned gtpu_reordering_timer_ms = 0;
+  bool     warn_on_drop             = false;
 };
 
 /// Configuration of logging functionalities.

apps/gnb/gnb_appconfig_cli11_schema.cpp

@@ -430,6 +430,10 @@ static void configure_cli11_cu_up_args(CLI::App& app, cu_up_appconfig& cu_up_par
                  cu_up_params.gtpu_reordering_timer_ms,
                  "GTP-U RX reordering timer (in milliseconds)")
       ->capture_default_str();
+  app.add_option("--warn_on_drop",
+                 cu_up_params.warn_on_drop,
+                 "Log a warning for dropped packets in GTP-U and PDCP due to full queues")
+      ->capture_default_str();
 }
 
 static void configure_cli11_expert_phy_args(CLI::App& app, expert_upper_phy_appconfig& expert_phy_params)

apps/gnb/gnb_appconfig_translators.cpp

@@ -261,6 +261,7 @@ srs_cu_up::cu_up_configuration srsran::generate_cu_up_config(const gnb_appconfig
   srs_cu_up::cu_up_configuration out_cfg;
   out_cfg.statistics_report_period     = std::chrono::seconds{config.metrics_cfg.cu_up_statistics_report_period};
   out_cfg.n3_cfg.gtpu_reordering_timer = std::chrono::milliseconds{config.cu_up_cfg.gtpu_reordering_timer_ms};
+  out_cfg.n3_cfg.warn_on_drop          = config.cu_up_cfg.warn_on_drop;
 
   if (config.amf_cfg.n3_bind_addr == "auto") {
     out_cfg.net_cfg.n3_bind_addr = config.amf_cfg.bind_addr;

include/srsran/cu_up/cu_up_configuration.h

@@ -48,6 +48,7 @@ struct network_interface_config {
 
 struct n3_interface_config {
   std::chrono::milliseconds gtpu_reordering_timer; // N3 reordering timer
+  bool                      warn_on_drop;
 };
 
 struct e1ap_config_params {

include/srsran/gtpu/gtpu_demux.h

@@ -16,6 +16,10 @@
 
 namespace srsran {
 
+struct gtpu_demux_cfg_t {
+  bool warn_on_drop;
+};
+
 /// The GTP-U demux component will only be relevant for the reception and de-multiplexing
 /// of GTP-U packets. It does not require Tx capabilities as the corresponding GTP-U entities
 /// will already be calling the corresponding UDP network gateway.

include/srsran/gtpu/gtpu_demux_factory.h

@@ -18,8 +18,9 @@
 namespace srsran {
 
 struct gtpu_demux_creation_request {
-  task_executor* cu_up_exec = nullptr;
-  dlt_pcap*      gtpu_pcap  = nullptr;
+  gtpu_demux_cfg_t cfg        = {};
+  task_executor*   cu_up_exec = nullptr;
+  dlt_pcap*        gtpu_pcap  = nullptr;
 };
 
 /// Creates an instance of an GTP-U demux object.

lib/cu_up/cu_up_impl.cpp

@@ -53,6 +53,7 @@ cu_up::cu_up(const cu_up_configuration& config_) : cfg(config_), main_ctrl_loop(
 
   // Create GTP-U demux
   gtpu_demux_creation_request demux_msg = {};
+  demux_msg.cfg.warn_on_drop            = cfg.n3_cfg.warn_on_drop;
   demux_msg.cu_up_exec                  = cfg.dl_executor;
   demux_msg.gtpu_pcap                   = cfg.gtpu_pcap;
   ngu_demux                             = create_gtpu_demux(demux_msg);

lib/gtpu/gtpu_demux_factory.cpp

@@ -17,5 +17,5 @@ std::unique_ptr<gtpu_demux> srsran::create_gtpu_demux(const gtpu_demux_creation_
 {
   report_fatal_error_if_not(msg.cu_up_exec, "CU-UP exec is uninitialized");
   report_fatal_error_if_not(msg.gtpu_pcap, "CU-UP exec is uninitialized");
-  return std::make_unique<gtpu_demux_impl>(*msg.cu_up_exec, *msg.gtpu_pcap);
+  return std::make_unique<gtpu_demux_impl>(msg.cfg, *msg.cu_up_exec, *msg.gtpu_pcap);
 }

lib/gtpu/gtpu_demux_impl.cpp

@@ -14,9 +14,10 @@
 
 using namespace srsran;
 
-gtpu_demux_impl::gtpu_demux_impl(task_executor& cu_up_exec_, dlt_pcap& gtpu_pcap_) :
-  cu_up_exec(cu_up_exec_), gtpu_pcap(gtpu_pcap_), logger(srslog::fetch_basic_logger("GTPU"))
+gtpu_demux_impl::gtpu_demux_impl(gtpu_demux_cfg_t cfg_, task_executor& cu_up_exec_, dlt_pcap& gtpu_pcap_) :
+  cfg(cfg_), cu_up_exec(cu_up_exec_), gtpu_pcap(gtpu_pcap_), logger(srslog::fetch_basic_logger("GTPU"))
 {
+  logger.info("GTP-U demux. {}", cfg);
 }
 
 bool gtpu_demux_impl::add_tunnel(gtpu_teid_t teid, gtpu_tunnel_rx_upper_layer_interface* tunnel)
@@ -53,7 +54,11 @@ void gtpu_demux_impl::handle_pdu(byte_buffer pdu, const sockaddr_storage& src_ad
     handle_pdu_impl(gtpu_teid_t{teid}, std::move(p), src_addr);
   };
   if (not cu_up_exec.execute(std::move(fn))) {
-    logger.info("Dropped GTP-U PDU, queue is full. teid={}", teid);
+    if (not cfg.warn_on_drop) {
+      logger.info("Dropped GTP-U PDU, queue is full. teid={}", teid);
+    } else {
+      logger.warning("Dropped GTP-U PDU, queue is full. teid={}", teid);
+    }
   }
 }
 

lib/gtpu/gtpu_demux_impl.h

@@ -13,6 +13,7 @@
 #include "srsran/gtpu/gtpu_demux.h"
 #include "srsran/pcap/dlt_pcap.h"
 #include "srsran/support/executors/task_executor.h"
+#include "fmt/format.h"
 #include <memory>
 #include <unordered_map>
 
@@ -21,7 +22,7 @@ namespace srsran {
 class gtpu_demux_impl final : public gtpu_demux
 {
 public:
-  explicit gtpu_demux_impl(task_executor& cu_up_exec, dlt_pcap& gtpu_pcap_);
+  explicit gtpu_demux_impl(gtpu_demux_cfg_t cfg_, task_executor& cu_up_exec, dlt_pcap& gtpu_pcap_);
   ~gtpu_demux_impl() = default;
 
   // gtpu_demux_rx_upper_layer_interface
@@ -35,8 +36,9 @@ class gtpu_demux_impl final : public gtpu_demux
   // Actual demuxing, to be run in CU-UP executor.
   void handle_pdu_impl(gtpu_teid_t teid, byte_buffer pdu, const sockaddr_storage& src_addr);
 
-  task_executor& cu_up_exec;
-  dlt_pcap&      gtpu_pcap;
+  const gtpu_demux_cfg_t cfg;
+  task_executor&         cu_up_exec;
+  dlt_pcap&              gtpu_pcap;
 
   ///< TODO: revisit mapping of TEID to executors, one executor per UE should be doable.
   std::unordered_map<gtpu_teid_t, gtpu_tunnel_rx_upper_layer_interface*, gtpu_teid_hasher_t> teid_to_tunnel;
@@ -45,3 +47,21 @@ class gtpu_demux_impl final : public gtpu_demux
 };
 
 } // namespace srsran
+
+namespace fmt {
+// GTP-U demux config formatter
+template <>
+struct formatter<srsran::gtpu_demux_cfg_t> {
+  template <typename ParseContext>
+  auto parse(ParseContext& ctx) -> decltype(ctx.begin())
+  {
+    return ctx.begin();
+  }
+
+  template <typename FormatContext>
+  auto format(srsran::gtpu_demux_cfg_t cfg, FormatContext& ctx) -> decltype(std::declval<FormatContext>().out())
+  {
+    return format_to(ctx.out(), "warn_on_drop={}", cfg.warn_on_drop);
+  }
+};
+} // namespace fmt