Remove deprecated internal API ebpf_allocate() (#4681)

* Remove deprecated ebpf_allocate() API

Replace all calls to deprecated ebpf_allocate() with ebpf_allocate_with_tag()
using EBPF_POOL_TAG_DEFAULT. This cleanup removes the deprecated internal API
as requested in issue #4674.

Changes:
- Replaced ebpf_allocate(size) calls with ebpf_allocate_with_tag(size, EBPF_POOL_TAG_DEFAULT)
- Removed deprecated ebpf_allocate() function definition from ebpf_shared_framework.h
- Updated all callers across the codebase to use the non-deprecated API

Fixes #4674

* Fix syntax errors in ebpf_allocate_with_tag calls

- Fix parentheses placement in macro definitions for malloc/calloc
- Fix parameter separation in function calls
- Ensure all calls use proper syntax: ebpf_allocate_with_tag(size, tag)

Fixes compilation errors in CI builds.

* Fix comprehensive syntax errors in ebpf_allocate_with_tag calls

Correct parentheses placement across 24 files where sizeof() parameters
were incorrectly grouped with EBPF_POOL_TAG_DEFAULT.

Changes:
- Fixed ~60 function calls with wrong syntax: sizeof(type, tag) -> sizeof(type), tag
- Corrected macro definitions for malloc/calloc in ubpf files
- Fixed multiplication order in array allocations
- Resolved all CI compilation errors from original API migration

All ebpf_allocate_with_tag calls now use proper two-parameter syntax.

Author: cnaples79

ebpfapi/rpc_client.cpp

@@ -193,7 +193,7 @@ clean_up_rpc_binding()
 _Must_inspect_result_ _Ret_maybenull_
 _Post_writable_byte_size_(size) void* __RPC_USER MIDL_user_allocate(_In_ size_t size)
 {
-    return ebpf_allocate(size);
+    return ebpf_allocate_with_tag(size, EBPF_POOL_TAG_DEFAULT);
 }
 
 void __RPC_USER

ebpfsvc/rpc_util.cpp

@@ -117,7 +117,7 @@ shutdown_rpc_server()
 _Must_inspect_result_ _Ret_maybenull_
 _Post_writable_byte_size_(size) void* __RPC_USER MIDL_user_allocate(_In_ size_t size)
 {
-    return ebpf_allocate(size);
+    return ebpf_allocate_with_tag(size, EBPF_POOL_TAG_DEFAULT);
 }
 
 void __RPC_USER

libs/api/Verifier.cpp

@@ -326,7 +326,7 @@ load_byte_code(
         }
 
         for (auto& raw_program : raw_programs) {
-            program = (ebpf_program_t*)ebpf_allocate(sizeof(ebpf_program_t));
+            program = (ebpf_program_t*)ebpf_allocate_with_tag(sizeof(ebpf_program_t), EBPF_POOL_TAG_DEFAULT);
             if (program == nullptr) {
                 result = EBPF_NO_MEMORY;
                 goto Exit;
@@ -348,7 +348,7 @@ load_byte_code(
                 goto Exit;
             }
             size_t ebpf_bytes = instruction_count * sizeof(ebpf_inst);
-            program->instructions = (ebpf_inst*)ebpf_allocate(ebpf_bytes);
+            program->instructions = (ebpf_inst*)ebpf_allocate_with_tag(ebpf_bytes, EBPF_POOL_TAG_DEFAULT);
             if (program->instructions == nullptr) {
                 result = EBPF_NO_MEMORY;
                 goto Exit;
@@ -405,7 +405,7 @@ load_byte_code(
                 goto Exit;
             }
 
-            map = (ebpf_map_t*)ebpf_allocate(sizeof(ebpf_map_t));
+            map = (ebpf_map_t*)ebpf_allocate_with_tag(sizeof(ebpf_map_t), EBPF_POOL_TAG_DEFAULT);
             if (map == nullptr) {
                 result = EBPF_NO_MEMORY;
                 goto Exit;
@@ -435,7 +435,7 @@ load_byte_code(
     } catch (std::runtime_error& err) {
         auto message = err.what();
         auto message_length = strlen(message) + 1;
-        char* error = reinterpret_cast<char*>(ebpf_allocate(message_length + 1));
+        char* error = reinterpret_cast<char*>(ebpf_allocate_with_tag(message_length + 1, EBPF_POOL_TAG_DEFAULT));
         if (error) {
             strcpy_s(error, message_length, message);
         }
@@ -468,7 +468,7 @@ load_byte_code(
 static void
 _ebpf_add_stat(_Inout_ ebpf_api_program_info_t* info, std::string key, int value) noexcept(false)
 {
-    ebpf_stat_t* stat = (ebpf_stat_t*)ebpf_allocate(sizeof(*stat));
+    ebpf_stat_t* stat = (ebpf_stat_t*)ebpf_allocate_with_tag(sizeof(*stat), EBPF_POOL_TAG_DEFAULT);
     if (stat == nullptr) {
         throw std::runtime_error("Out of memory");
     }
@@ -503,7 +503,7 @@ ebpf_api_elf_enumerate_programs(
     try {
         auto raw_programs = read_elf(file, section ? std::string(section) : std::string(), verifier_options, platform);
         for (const auto& raw_program : raw_programs) {
-            info = (ebpf_api_program_info_t*)ebpf_allocate(sizeof(*info));
+            info = (ebpf_api_program_info_t*)ebpf_allocate_with_tag(sizeof(*info), EBPF_POOL_TAG_DEFAULT);
             if (info == nullptr) {
                 throw std::runtime_error("Out of memory");
             }
@@ -548,7 +548,7 @@ ebpf_api_elf_enumerate_programs(
             info->offset_in_section = raw_program.insn_off;
             std::vector<uint8_t> raw_data = convert_ebpf_program_to_bytes(raw_program.prog);
             info->raw_data_size = raw_data.size();
-            info->raw_data = (char*)ebpf_allocate(info->raw_data_size);
+            info->raw_data = (char*)ebpf_allocate_with_tag(info->raw_data_size, EBPF_POOL_TAG_DEFAULT);
             if (info->raw_data == nullptr) {
                 throw std::runtime_error("Out of memory");
             }

libs/api/ebpf_api.cpp

@@ -1483,8 +1483,8 @@ ebpf_program_query_info(
 
     size_t file_name_length = reply->section_name_offset - reply->file_name_offset;
     size_t section_name_length = reply->header.length - reply->section_name_offset;
-    char* local_file_name = reinterpret_cast<char*>(ebpf_allocate(file_name_length + 1));
-    char* local_section_name = reinterpret_cast<char*>(ebpf_allocate(section_name_length + 1));
+    char* local_file_name = reinterpret_cast<char*>(ebpf_allocate_with_tag(file_name_length + 1, EBPF_POOL_TAG_DEFAULT));
+    char* local_section_name = reinterpret_cast<char*>(ebpf_allocate_with_tag(section_name_length + 1, EBPF_POOL_TAG_DEFAULT));
 
     if (!local_file_name || !local_section_name) {
         ebpf_free(local_file_name);
@@ -1656,7 +1656,7 @@ ebpf_program_attach(
 
     ebpf_assert(program);
 
-    ebpf_link_t* new_link = (ebpf_link_t*)ebpf_allocate(sizeof(ebpf_link_t));
+    ebpf_link_t* new_link = (ebpf_link_t*)ebpf_allocate_with_tag(sizeof(ebpf_link_t), EBPF_POOL_TAG_DEFAULT);
     if (new_link == nullptr) {
         EBPF_RETURN_RESULT(EBPF_NO_MEMORY);
     }
@@ -1712,7 +1712,7 @@ ebpf_program_attach_by_fd(
     EBPF_LOG_ENTRY();
     ebpf_assert(link);
 
-    ebpf_link_t* new_link = (ebpf_link_t*)ebpf_allocate(sizeof(ebpf_link_t));
+    ebpf_link_t* new_link = (ebpf_link_t*)ebpf_allocate_with_tag(sizeof(ebpf_link_t), EBPF_POOL_TAG_DEFAULT);
     if (new_link == nullptr) {
         EBPF_RETURN_RESULT(EBPF_NO_MEMORY);
     }
@@ -2286,7 +2286,7 @@ _initialize_ebpf_object_from_native_file(
     object.execution_type = EBPF_EXECUTION_NATIVE;
 
     for (ebpf_api_program_info_t* info = infos; info; info = info->next) {
-        program = (ebpf_program_t*)ebpf_allocate(sizeof(ebpf_program_t));
+        program = (ebpf_program_t*)ebpf_allocate_with_tag(sizeof(ebpf_program_t), EBPF_POOL_TAG_DEFAULT);
         if (program == nullptr) {
             result = EBPF_NO_MEMORY;
             goto Exit;
@@ -2580,7 +2580,7 @@ _ebpf_pe_get_map_definitions(
                     break;
                 }
 
-                map = (ebpf_map_t*)ebpf_allocate(sizeof(ebpf_map_t));
+                map = (ebpf_map_t*)ebpf_allocate_with_tag(sizeof(ebpf_map_t), EBPF_POOL_TAG_DEFAULT);
                 if (map == nullptr) {
                     goto Error;
                 }
@@ -2759,7 +2759,7 @@ _ebpf_pe_add_section(
     std::string elf_section_name = pe_context->section_names[pe_section_name];
     std::string program_name = pe_context->program_names[pe_section_name];
 
-    ebpf_api_program_info_t* info = (ebpf_api_program_info_t*)ebpf_allocate(sizeof(*info));
+    ebpf_api_program_info_t* info = (ebpf_api_program_info_t*)ebpf_allocate_with_tag(sizeof(*info), EBPF_POOL_TAG_DEFAULT);
     if (info == nullptr) {
         pe_context->result = EBPF_NO_MEMORY;
         return_value = 1;
@@ -2785,7 +2785,7 @@ _ebpf_pe_add_section(
     info->expected_attach_type = pe_context->section_attach_types[pe_section_name];
 
     info->raw_data_size = section_header.Misc.VirtualSize;
-    info->raw_data = (char*)ebpf_allocate(section_header.Misc.VirtualSize);
+    info->raw_data = (char*)ebpf_allocate_with_tag(section_header.Misc.VirtualSize, EBPF_POOL_TAG_DEFAULT);
     if (info->raw_data == nullptr || info->section_name == nullptr) {
         pe_context->result = EBPF_NO_MEMORY;
         return_value = 1;
@@ -3633,7 +3633,7 @@ _load_native_programs(
     size_t buffer_size = offsetof(ebpf_operation_load_native_programs_reply_t, data) + handles_size;
 
     if (count_of_maps > 0) {
-        *map_handles = (ebpf_handle_t*)ebpf_allocate(map_handles_size);
+        *map_handles = (ebpf_handle_t*)ebpf_allocate_with_tag(map_handles_size, EBPF_POOL_TAG_DEFAULT);
         if (*map_handles == nullptr) {
             EBPF_LOG_MESSAGE(
                 EBPF_TRACELOG_LEVEL_ERROR,
@@ -3645,7 +3645,7 @@ _load_native_programs(
     }
 
     if (count_of_programs > 0) {
-        *program_handles = (ebpf_handle_t*)ebpf_allocate(program_handles_size);
+        *program_handles = (ebpf_handle_t*)ebpf_allocate_with_tag(program_handles_size, EBPF_POOL_TAG_DEFAULT);
         if (*program_handles == nullptr) {
             EBPF_LOG_MESSAGE(
                 EBPF_TRACELOG_LEVEL_ERROR,

libs/api/libbpf_link.cpp

@@ -20,7 +20,7 @@ bpf_link__open(const char* path)
         return nullptr;
     }
 
-    link = (struct bpf_link*)ebpf_allocate(sizeof(struct bpf_link));
+    link = (struct bpf_link*)ebpf_allocate_with_tag(sizeof(struct bpf_link), EBPF_POOL_TAG_DEFAULT);
     if (!link) {
         (void)ebpf_close_fd(link_fd);
         libbpf_err(-ENOMEM);

libs/api_common/api_common.cpp

@@ -21,7 +21,7 @@ allocate_string(const std::string& string, uint32_t* length) noexcept
 {
     char* new_string;
     size_t string_length = string.size() + 1;
-    new_string = (char*)ebpf_allocate(string_length);
+    new_string = (char*)ebpf_allocate_with_tag(string_length, EBPF_POOL_TAG_DEFAULT);
     if (new_string != nullptr) {
         strcpy_s(new_string, string_length, string.c_str());
         if (length != nullptr) {

libs/api_common/device_helper.cpp

@@ -210,7 +210,7 @@ initialize_async_ioctl_operation(
     *async_ioctl_completion = nullptr;
 
     async_ioctl_completion_context_t* local_async_ioctl_completion =
-        (async_ioctl_completion_context_t*)ebpf_allocate(sizeof(async_ioctl_completion_context_t));
+        (async_ioctl_completion_context_t*)ebpf_allocate_with_tag(sizeof(async_ioctl_completion_context_t), EBPF_POOL_TAG_DEFAULT);
     if (local_async_ioctl_completion == nullptr) {
         result = EBPF_NO_MEMORY;
         goto Exit;

libs/api_common/store_helper_internal.cpp

@@ -164,7 +164,7 @@ _ebpf_store_load_program_type_descriptor(
 
     // Allocate the program type descriptor.
     local_program_type_descriptor =
-        (ebpf_program_type_descriptor_t*)ebpf_allocate(sizeof(ebpf_program_type_descriptor_t));
+        (ebpf_program_type_descriptor_t*)ebpf_allocate_with_tag(sizeof(ebpf_program_type_descriptor_t), EBPF_POOL_TAG_DEFAULT);
     if (local_program_type_descriptor == nullptr) {
         result = EBPF_NO_MEMORY;
         goto Exit;
@@ -197,7 +197,7 @@ _ebpf_store_load_program_type_descriptor(
     }
 
     // Allocate and read context descriptor.
-    context_descriptor = (ebpf_context_descriptor_t*)ebpf_allocate(sizeof(ebpf_context_descriptor_t));
+    context_descriptor = (ebpf_context_descriptor_t*)ebpf_allocate_with_tag(sizeof(ebpf_context_descriptor_t), EBPF_POOL_TAG_DEFAULT);
     if (context_descriptor == nullptr) {
         result = EBPF_NO_MEMORY;
         goto Exit;
@@ -276,7 +276,7 @@ _ebpf_store_load_program_information(
     }
 
     // Allocate the program information struct.
-    program_information = (ebpf_program_info_t*)ebpf_allocate(sizeof(ebpf_program_info_t));
+    program_information = (ebpf_program_info_t*)ebpf_allocate_with_tag(sizeof(ebpf_program_info_t), EBPF_POOL_TAG_DEFAULT);
     if (program_information == nullptr) {
         result = EBPF_NO_MEMORY;
         goto Exit;
@@ -289,7 +289,7 @@ _ebpf_store_load_program_information(
     }
 
     // Allocate and read the program type GUID.
-    program_type = (ebpf_program_type_t*)ebpf_allocate(sizeof(ebpf_program_type_t));
+    program_type = (ebpf_program_type_t*)ebpf_allocate_with_tag(sizeof(ebpf_program_type_t), EBPF_POOL_TAG_DEFAULT);
     if (program_type == nullptr) {
         result = EBPF_NO_MEMORY;
         goto Exit;
@@ -353,7 +353,7 @@ _ebpf_store_load_program_information(
         }
 
         ebpf_helper_function_prototype_t* helper_prototype =
-            (ebpf_helper_function_prototype_t*)ebpf_allocate(helper_count * sizeof(ebpf_helper_function_prototype_t));
+            (ebpf_helper_function_prototype_t*)ebpf_allocate_with_tag(helper_count * sizeof(ebpf_helper_function_prototype_t), EBPF_POOL_TAG_DEFAULT);
         if (helper_prototype == nullptr) {
             result = EBPF_NO_MEMORY;
             goto Exit;
@@ -363,7 +363,7 @@ _ebpf_store_load_program_information(
         // Add space for null terminator.
         max_helper_name_size += 1;
 
-        helper_name = (wchar_t*)ebpf_allocate(max_helper_name_size * sizeof(wchar_t));
+        helper_name = (wchar_t*)ebpf_allocate_with_tag(max_helper_name_size * sizeof(wchar_t), EBPF_POOL_TAG_DEFAULT);
         if (helper_name == nullptr) {
             result = EBPF_NO_MEMORY;
             goto Exit;
@@ -486,7 +486,7 @@ ebpf_store_load_program_data(
         if (program_info_array.size() > 0) {
             // Copy the vector data to a new array.
             auto size = program_info_array.size() * sizeof(ebpf_program_info_t*);
-            *program_info = (ebpf_program_info_t**)ebpf_allocate(size);
+            *program_info = (ebpf_program_info_t**)ebpf_allocate_with_tag(size, EBPF_POOL_TAG_DEFAULT);
             if (*program_info == nullptr) {
                 result = EBPF_NO_MEMORY;
                 goto Exit;
@@ -544,13 +544,13 @@ _load_section_data_information(
             goto Exit;
         }
 
-        program_type = (ebpf_program_type_t*)ebpf_allocate(sizeof(ebpf_program_type_t));
+        program_type = (ebpf_program_type_t*)ebpf_allocate_with_tag(sizeof(ebpf_program_type_t), EBPF_POOL_TAG_DEFAULT);
         if (program_type == nullptr) {
             result = EBPF_NO_MEMORY;
             goto Exit;
         }
 
-        attach_type = (ebpf_attach_type_t*)ebpf_allocate(sizeof(ebpf_attach_type_t));
+        attach_type = (ebpf_attach_type_t*)ebpf_allocate_with_tag(sizeof(ebpf_attach_type_t), EBPF_POOL_TAG_DEFAULT);
         if (attach_type == nullptr) {
             result = EBPF_NO_MEMORY;
             goto Exit;
@@ -594,7 +594,7 @@ _load_section_data_information(
             goto Exit;
         }
 
-        section_information = (ebpf_section_definition_t*)ebpf_allocate(sizeof(ebpf_section_definition_t));
+        section_information = (ebpf_section_definition_t*)ebpf_allocate_with_tag(sizeof(ebpf_section_definition_t), EBPF_POOL_TAG_DEFAULT);
         if (section_information == nullptr) {
             result = EBPF_NO_MEMORY;
             goto Exit;
@@ -691,7 +691,7 @@ ebpf_store_load_section_information(
         if (section_info_array.size() > 0) {
             // Copy the vector data to a new array.
             auto size = section_info_array.size() * sizeof(ebpf_section_definition_t*);
-            *section_info = (ebpf_section_definition_t**)ebpf_allocate(size);
+            *section_info = (ebpf_section_definition_t**)ebpf_allocate_with_tag(size, EBPF_POOL_TAG_DEFAULT);
             if (*section_info == nullptr) {
                 result = EBPF_NO_MEMORY;
                 goto Exit;
@@ -794,14 +794,14 @@ ebpf_store_load_global_helper_information(
     // Add space for null terminator.
     max_helper_name_size += 1;
 
-    helper_name = (wchar_t*)ebpf_allocate(max_helper_name_size * sizeof(wchar_t));
+    helper_name = (wchar_t*)ebpf_allocate_with_tag(max_helper_name_size * sizeof(wchar_t), EBPF_POOL_TAG_DEFAULT);
     if (helper_name == nullptr) {
         result = EBPF_NO_MEMORY;
         goto Exit;
     }
 
     helper_prototype =
-        (ebpf_helper_function_prototype_t*)ebpf_allocate(max_helpers_count * sizeof(ebpf_helper_function_prototype_t));
+        (ebpf_helper_function_prototype_t*)ebpf_allocate_with_tag(max_helpers_count * sizeof(ebpf_helper_function_prototype_t), EBPF_POOL_TAG_DEFAULT);
     if (helper_prototype == nullptr) {
         result = EBPF_NO_MEMORY;
         goto Exit;

libs/api_common/windows_platform_common.cpp

@@ -158,7 +158,7 @@ _get_program_descriptor_from_info(
             goto Exit;
         }
         type->name = std::string(name);
-        type->context_descriptor = (ebpf_context_descriptor_t*)ebpf_allocate(sizeof(ebpf_context_descriptor_t));
+        type->context_descriptor = (ebpf_context_descriptor_t*)ebpf_allocate_with_tag(sizeof(ebpf_context_descriptor_t), EBPF_POOL_TAG_DEFAULT);
         if (type->context_descriptor == nullptr) {
             result = EBPF_NO_MEMORY;
             goto Exit;
@@ -167,7 +167,7 @@ _get_program_descriptor_from_info(
             (void*)type->context_descriptor,
             info->program_type_descriptor->context_descriptor,
             sizeof(ebpf_context_descriptor_t));
-        ebpf_program_type_t* program_type = (ebpf_program_type_t*)ebpf_allocate(sizeof(ebpf_program_type_t));
+        ebpf_program_type_t* program_type = (ebpf_program_type_t*)ebpf_allocate_with_tag(sizeof(ebpf_program_type_t), EBPF_POOL_TAG_DEFAULT);
         if (program_type == nullptr) {
             result = EBPF_NO_MEMORY;
             goto Exit;
@@ -535,7 +535,7 @@ _update_global_helpers_for_program_information(
             goto Exit;
         }
         total_helper_size = total_helper_count * sizeof(ebpf_helper_function_prototype_t);
-        new_helpers = (ebpf_helper_function_prototype_t*)ebpf_allocate(total_helper_size);
+        new_helpers = (ebpf_helper_function_prototype_t*)ebpf_allocate_with_tag(total_helper_size, EBPF_POOL_TAG_DEFAULT);
         if (new_helpers == nullptr) {
             result = EBPF_NO_MEMORY;
             break;

libs/execution_context/ebpf_core.c

@@ -1161,7 +1161,7 @@ _ebpf_core_protocol_program_test_run(
         goto Done;
     }
 
-    options = (ebpf_program_test_run_options_t*)ebpf_allocate(sizeof(ebpf_program_test_run_options_t));
+    options = (ebpf_program_test_run_options_t*)ebpf_allocate_with_tag(sizeof(ebpf_program_test_run_options_t), EBPF_POOL_TAG_DEFAULT);
     if (!options) {
         retval = EBPF_NO_MEMORY;
         goto Done;