issue: 4561820 Fix type validation for integers

Integer configuration parameters were incorrectly accepting boolean
and string values instead of throwing type validation errors.
This fix adds proper type checking in parameter_descriptor::get_value()
to ensure type safety.

Changes:
- Add type validation check to reject mismatched types
- Remove deprecated kernel_fd_attention_level parameter from schema
- Update tests to verify type validation works correctly for all types
- Add comprehensive unit tests for type mismatch scenarios

Fixes issue where these integer parameters accepted invalid types:
- performance.rings.tx.udp_buffer_batch
- performance.polling.kernel_fd_attention_level (now removed)
- performance.buffers.tx.global_array_size

The fix ensures that boolean and string values are properly rejected for
integer parameters, causing configuration loading to fail with
appropriate error messages instead of silently accepting invalid values.

Signed-off-by: Tomer Cabouly <[email protected]>

Author: tomerdbz

README

@@ -666,10 +666,6 @@ performance.polling.iomux.skip_os
 For select() or poll() this will force XLIO to check the non offloaded fd even though an offloaded socket has ready packets found while polling. Maps to **XLIO_SELECT_SKIP_OS** environment variable.
 Default value is 4
 
-performance.polling.kernel_fd_attention_level
-Controls threshold for checking kernel file descriptors during polling. 0 means never check. Maps to **XLIO_RING_KERNEL_FD_ATTENTION_LEVEL** environment variable. This setting affects how often XLIO checks for activity on non-offloaded kernel file descriptors while processing offloaded sockets.
-Default value is 10
-
 performance.polling.max_rx_poll_batch
 Maximum number of receive buffers processed in a single poll operation. Maps to **XLIO_CQ_POLL_BATCH_MAX** environment variable. Max size of the array while polling the CQs in the XLIO.
 Default value is 16

src/core/config/descriptor_providers/xlio_config_schema.json

@@ -1026,13 +1026,6 @@
                             "title": "Offload transition poll count",
                             "description": "XLIO maps all UDP sockets as potential offloaded capable. Only after the ADD_MEMBERSHIP does the offload start to work and the CQ polling kicks in XLIO. This parameter controls the polling count during this transition phase where the socket is a UDP unicast socket and no multicast addresses were added to it. Once the first ADD_MEMBERSHIP is called the RX poll duration setting takes effect. Value range is similar to the RX poll duration; -1 means infinite, 0 disables. Maps to XLIO_RX_POLL_INIT environment variable."
                         },
-                        "kernel_fd_attention_level": {
-                            "type": "integer",
-                            "minimum": 0,
-                            "default": 10,
-                            "title": "Kernel FD attention threshold",
-                            "description": "Controls threshold for checking kernel file descriptors during polling. 0 means never check. Maps to XLIO_RING_KERNEL_FD_ATTENTION_LEVEL environment variable. This setting affects how often XLIO checks for activity on non-offloaded kernel file descriptors while processing offloaded sockets."
-                        },
                         "max_rx_poll_batch": {
                             "type": "integer",
                             "minimum": 0,

src/core/config/descriptors/parameter_descriptor.cpp

@@ -179,32 +179,74 @@ void parameter_descriptor::add_constraint(constraint_t constraint)
     m_constraints.push_back(std::move(constraint));
 }
 
-std::experimental::any parameter_descriptor::get_value(const std::experimental::any &val) const
+std::experimental::any parameter_descriptor::convert_string_to_int64(const std::string &val) const
 {
-    std::experimental::any result = val;
-
-    // First, apply string mappings if applicable
-    if (result.type() == typeid(std::string)) {
-        auto it = m_string_mapping.find(std::experimental::any_cast<std::string>(result));
-        if (it != m_string_mapping.end()) {
-            result = it->second;
+    // Try value transformer first (e.g., "1GB" -> 1073741824)
+    if (m_value_transformer) {
+        std::experimental::any result = m_value_transformer(std::experimental::any(val));
+        if (std::type_index(result.type()) != m_type) {
+            throw std::experimental::bad_any_cast();
         }
+        return result;
     }
 
-    // Then apply value transformer if available
-    if (m_value_transformer) {
-        result = m_value_transformer(result);
+    // Try string mapping (e.g., "enabled" -> 1)
+    auto it = m_string_mapping.find(val);
+    if (it != m_string_mapping.end()) {
+        return it->second;
+    }
+
+    throw std::experimental::bad_any_cast();
+}
+
+std::experimental::any parameter_descriptor::get_value(bool val) const
+{
+    // For boolean values, no string mapping or transformation is typically needed
+    // Just validate that the parameter type is boolean
+    if (m_type != typeid(bool)) {
+        throw std::experimental::bad_any_cast();
+    }
+
+    return std::experimental::any(val);
+}
+
+std::experimental::any parameter_descriptor::get_value(const std::string &val) const
+{
+    // Case 1: Parameter expects string - direct pass-through
+    if (m_type == typeid(std::string)) {
+        return std::experimental::any(val);
+    }
+
+    // Case 2: Parameter expects int64_t - convert string via transformer or mapping
+    if (m_type == typeid(int64_t)) {
+        return convert_string_to_int64(val);
     }
 
-    // Validate type compatibility for string mappings
-    if (!m_string_mapping.empty() && result.type() != typeid(int64_t) &&
-        result.type() != typeid(std::string)) {
-        // If there is a string mapping, then the value must be a string or an int as it represents
-        // an enum
+    // Case 3: Unsupported type conversion
+    throw std::experimental::bad_any_cast();
+}
+
+std::experimental::any parameter_descriptor::get_value(int64_t val) const
+{
+    if (m_type != typeid(int64_t)) {
         throw std::experimental::bad_any_cast();
     }
+    return std::experimental::any(val);
+}
 
-    return result;
+std::experimental::any parameter_descriptor::get_value(const std::experimental::any &val) const
+{
+    // Dispatch to type-specific convenience methods based on the input type
+    if (val.type() == typeid(bool)) {
+        return get_value(std::experimental::any_cast<bool>(val));
+    } else if (val.type() == typeid(std::string)) {
+        return get_value(std::experimental::any_cast<std::string>(val));
+    } else if (val.type() == typeid(int64_t)) {
+        return get_value(std::experimental::any_cast<int64_t>(val));
+    } else {
+        // For unsupported types, throw an exception
+        throw std::experimental::bad_any_cast();
+    }
 }
 
 void parameter_descriptor::validate_constraints(const std::experimental::any &value) const

src/core/config/descriptors/parameter_descriptor.h

@@ -110,6 +110,28 @@ class parameter_descriptor {
      */
     std::experimental::any get_value(const std::experimental::any &val) const;
 
+    /**
+     * @brief Type-specific get_value for boolean values
+     * @param val Boolean input value
+     * @return Resolved boolean value as std::experimental::any
+     */
+    std::experimental::any get_value(bool val) const;
+
+    /**
+     * @brief Type-specific get_value for string values
+     * @param val String input value
+     * @return Resolved value (mapped and transformed value if applicable, original otherwise) as
+     * std::experimental::any
+     */
+    std::experimental::any get_value(const std::string &val) const;
+
+    /**
+     * @brief Type-specific get_value for int64_t values
+     * @param val int64_t input value
+     * @return Resolved int64_t value as std::experimental::any
+     */
+    std::experimental::any get_value(int64_t val) const;
+
     /**
      * @brief Gets the type of the parameter
      * @return The type of the parameter
@@ -125,6 +147,21 @@ class parameter_descriptor {
 private:
     static int64_t parse_memory_size(const char *str);
 
+    /**
+     * @brief Check if the given type matches the expected parameter type
+     * @param type The type to check
+     * @return True if the type matches the expected parameter type
+     */
+    bool is_expected_type(const std::type_index &type) const;
+
+    /**
+     * @brief Convert a string value to int64_t using transformer or string mapping
+     * @param val The string value to convert
+     * @return The converted int64_t value as std::experimental::any
+     * @throws std::experimental::bad_any_cast if conversion fails
+     */
+    std::experimental::any convert_string_to_int64(const std::string &val) const;
+
     std::experimental::any m_default_value; /**< Default parameter value */
     std::vector<constraint_t> m_constraints; /**< Validation constraints */
     std::map<std::string, std::experimental::any> m_string_mapping; /**< String-to-value mappings */

src/core/config/mappings.py

@@ -85,7 +85,6 @@
     "performance.polling.iomux.poll_os_ratio": "XLIO_SELECT_POLL_OS_RATIO",
     "performance.polling.iomux.poll_usec": "XLIO_SELECT_POLL",
     "performance.polling.iomux.skip_os": "XLIO_SELECT_SKIP_OS",
-    "performance.polling.kernel_fd_attention_level": "XLIO_RING_KERNEL_FD_ATTENTION_LEVEL",
     "performance.polling.max_rx_poll_batch": "XLIO_CQ_POLL_BATCH_MAX",
     "performance.polling.nonblocking_eagain": "XLIO_TX_NONBLOCKED_EAGAINS",
     "performance.polling.offload_transition_poll_count": "XLIO_RX_POLL_INIT",

tests/unit_tests/config/config_registry.cpp

@@ -504,3 +504,131 @@ TEST(config, config_registry_memory_size_transformer_inline_config)
     // 2GB = 2 * 1024 * 1024 * 1024 = 2147483648 bytes
     ASSERT_EQ(2147483648LL, registry.get_value<int64_t>("core.memory_limit"));
 }
+
+// Helper descriptor for type validation tests
+static const char *sample_type_validation_descriptor = R"({
+    "$schema": "http://json-schema.org/draft-07/schema#",
+    "title": "XLIO Configuration Schema",
+    "description": "Schema for XLIO configuration",
+    "type": "object",
+    "properties": {
+        "performance": {
+            "type": "object",
+            "description": "Performance-related settings",
+            "properties": {
+                "rings": {
+                    "type": "object",
+                    "description": "Ring configuration",
+                    "properties": {
+                        "tx": {
+                            "type": "object",
+                            "description": "Transmission ring settings",
+                            "properties": {
+                                "udp_buffer_batch": {
+                                    "type": "integer",
+                                    "default": 16,
+                                    "minimum": 1,
+                                    "title": "TX buffer batch size",
+                                    "description": "Number of TX buffers fetched by a UDP socket at once"
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+})";
+
+TEST(config, config_registry_boolean_type_mismatch_throws)
+{
+    // Test that boolean values are rejected for integer parameters during loading
+    // This test specifically catches the bug where boolean values were accepted for integer
+    // parameters
+
+    conf_file_writer json_config(R"({
+        "performance": {
+            "rings": {
+                "tx": {
+                    "udp_buffer_batch": true
+                }
+            }
+        }
+    })");
+
+    std::queue<std::unique_ptr<loader>> loaders;
+    loaders.push(std::make_unique<json_loader>(json_config.get()));
+
+    ASSERT_THROW(config_registry(
+                     std::move(loaders),
+                     std::make_unique<json_descriptor_provider>(sample_type_validation_descriptor)),
+                 xlio_exception);
+}
+
+TEST(config, config_registry_string_type_mismatch_throws)
+{
+    // Test that string values are rejected for integer parameters during loading
+
+    conf_file_writer json_config(R"({
+        "performance": {
+            "rings": {
+                "tx": {
+                    "udp_buffer_batch": "invalid"
+                }
+            }
+        }
+    })");
+
+    std::queue<std::unique_ptr<loader>> loaders;
+    loaders.push(std::make_unique<json_loader>(json_config.get()));
+
+    ASSERT_THROW(config_registry(
+                     std::move(loaders),
+                     std::make_unique<json_descriptor_provider>(sample_type_validation_descriptor)),
+                 xlio_exception);
+}
+
+TEST(config, config_registry_valid_integer_works)
+{
+    // Test that valid integer values work correctly
+    conf_file_writer json_config(R"({
+        "performance": {
+            "rings": {
+                "tx": {
+                    "udp_buffer_batch": 32
+                }
+            }
+        }
+    })");
+
+    std::queue<std::unique_ptr<loader>> loaders;
+    loaders.push(std::make_unique<json_loader>(json_config.get()));
+
+    config_registry registry(
+        std::move(loaders),
+        std::make_unique<json_descriptor_provider>(sample_type_validation_descriptor));
+
+    ASSERT_EQ(32LL, registry.get_value<int64_t>("performance.rings.tx.udp_buffer_batch"));
+}
+
+TEST(config, config_registry_missing_uses_default)
+{
+    // Test that missing parameters use their default values
+
+    conf_file_writer json_config(R"({
+        "performance": {
+            "rings": {
+                "tx": {}
+            }
+        }
+    })");
+
+    std::queue<std::unique_ptr<loader>> loaders;
+    loaders.push(std::make_unique<json_loader>(json_config.get()));
+
+    config_registry registry(
+        std::move(loaders),
+        std::make_unique<json_descriptor_provider>(sample_type_validation_descriptor));
+
+    ASSERT_EQ(16LL, registry.get_value<int64_t>("performance.rings.tx.udp_buffer_batch"));
+}

tests/unit_tests/config/json_descriptor_provider.cpp

@@ -601,10 +601,8 @@ TEST(config, json_descriptor_provider_memory_size_transformer_applied)
     int64_t transformed_value = std::experimental::any_cast<int64_t>(transformed);
     ASSERT_EQ(1073741824LL, transformed_value); // 1GB in bytes
 
-    // Test that parameter without transformer doesn't transform strings
-    std::experimental::any untransformed = without_transformer.get_value(gb_string);
-    std::string untransformed_value = std::experimental::any_cast<std::string>(untransformed);
-    ASSERT_EQ("1GB", untransformed_value); // Should remain as string
+    // Test that parameter without transformer throws an exception
+    ASSERT_THROW(without_transformer.get_value(gb_string), std::experimental::bad_any_cast);
 }
 
 /**

tests/unit_tests/config/parameter_descriptor.cpp

@@ -385,4 +385,66 @@ TEST_F(memory_size_transformer, test_overflow)
 {
     // A very large number without suffix that fits uint64_t but not int64_t
     ASSERT_THROW(transformer(std::string("10000000000000000000")), xlio_exception);
-}
+}
+
+TEST(config, parameter_descriptor_valid_integer_passes)
+{
+    // Test that valid integer values pass through unchanged
+    constexpr int64_t DEFAULT_INT_VALUE = 16;
+    parameter_descriptor int_param_descriptor {std::experimental::any(int64_t(DEFAULT_INT_VALUE))};
+
+    std::experimental::any valid_int = int64_t(32);
+    std::experimental::any result = int_param_descriptor.get_value(valid_int);
+    ASSERT_EQ(typeid(int64_t), result.type());
+    ASSERT_EQ(32LL, std::experimental::any_cast<int64_t>(result));
+}
+
+TEST(config, parameter_descriptor_boolean_rejected)
+{
+    // Test that boolean values are rejected for integer parameters (this was the bug)
+    constexpr int64_t DEFAULT_INT_VALUE = 16;
+    parameter_descriptor int_param_descriptor {std::experimental::any(int64_t(DEFAULT_INT_VALUE))};
+
+    std::experimental::any bool_value = true;
+    ASSERT_THROW(int_param_descriptor.get_value(bool_value), std::experimental::bad_any_cast);
+}
+
+TEST(config, parameter_descriptor_string_rejected)
+{
+    // Test that string values are rejected for integer parameters
+    constexpr int64_t DEFAULT_INT_VALUE = 16;
+    parameter_descriptor int_param_descriptor {std::experimental::any(int64_t(DEFAULT_INT_VALUE))};
+
+    std::experimental::any string_value = std::string("invalid");
+    ASSERT_THROW(int_param_descriptor.get_value(string_value), std::experimental::bad_any_cast);
+}
+
+TEST(config, parameter_descriptor_double_rejected)
+{
+    // Test that double values are rejected for integer parameters
+    constexpr int64_t DEFAULT_INT_VALUE = 16;
+    parameter_descriptor int_param_descriptor {std::experimental::any(int64_t(DEFAULT_INT_VALUE))};
+
+    std::experimental::any double_value = 3.14;
+    ASSERT_THROW(int_param_descriptor.get_value(double_value), std::experimental::bad_any_cast);
+}
+
+TEST(config, parameter_descriptor_boolean_accepts_boolean)
+{
+    // Test that boolean parameters accept boolean values
+    parameter_descriptor bool_param_descriptor(std::experimental::any(bool(false)));
+
+    std::experimental::any bool_value = true;
+    std::experimental::any result = bool_param_descriptor.get_value(bool_value);
+    ASSERT_EQ(typeid(bool), result.type());
+    ASSERT_EQ(true, std::experimental::any_cast<bool>(result));
+}
+
+TEST(config, parameter_descriptor_boolean_rejects_integer)
+{
+    // Test that boolean parameters reject integer values
+    parameter_descriptor bool_param_descriptor(std::experimental::any(bool(false)));
+
+    std::experimental::any int_value = int64_t(1);
+    ASSERT_THROW(bool_param_descriptor.get_value(int_value), std::experimental::bad_any_cast);
+}