Support TraceLoggingBinary for map find, update and delete.

libs/execution_context/ebpf_maps.c

@@ -2450,6 +2450,20 @@ ebpf_map_find_entry(
 {
     // High volume call - Skip entry/exit logging.
     uint8_t* return_value = NULL;
+
+#ifdef _DEBUG
+    if ((flags & EBPF_MAP_FLAG_HELPER)) {
+        EBPF_LOG_MESSAGE_BINARY(
+            EBPF_TRACELOG_LEVEL_INFO,
+            EBPF_TRACELOG_KEYWORD_MAP,
+            "Map lookup",
+            _ebpf_map_display_names[map->ebpf_map_definition.type],
+            &map->name,
+            key,
+            map->ebpf_map_definition.key_size);
+    }
+#endif // _DEBUG
+
     if (!(flags & EBPF_MAP_FLAG_HELPER) && (key_size != map->ebpf_map_definition.key_size)) {
         EBPF_LOG_MESSAGE_UINT64_UINT64(
             EBPF_TRACELOG_LEVEL_ERROR,
@@ -2564,6 +2578,19 @@ ebpf_map_update_entry(
     // High volume call - Skip entry/exit logging.
     ebpf_result_t result;
 
+#ifdef _DEBUG
+    if ((flags & EBPF_MAP_FLAG_HELPER)) {
+        EBPF_LOG_MESSAGE_BINARY(
+            EBPF_TRACELOG_LEVEL_INFO,
+            EBPF_TRACELOG_KEYWORD_MAP,
+            "Map update",
+            _ebpf_map_display_names[map->ebpf_map_definition.type],
+            &map->name,
+            key,
+            map->ebpf_map_definition.key_size);
+    }
+#endif // _DEBUG
+
     if (ebpf_map_metadata_tables[map->ebpf_map_definition.type].zero_length_key) {
         if (key_size != 0) {
             EBPF_LOG_MESSAGE_UINT64(
@@ -2649,6 +2676,20 @@ _Must_inspect_result_ ebpf_result_t
 ebpf_map_delete_entry(_In_ ebpf_map_t* map, size_t key_size, _In_reads_(key_size) const uint8_t* key, int flags)
 {
     // High volume call - Skip entry/exit logging.
+
+#ifdef _DEBUG
+    if ((flags & EBPF_MAP_FLAG_HELPER)) {
+        EBPF_LOG_MESSAGE_BINARY(
+            EBPF_TRACELOG_LEVEL_INFO,
+            EBPF_TRACELOG_KEYWORD_MAP,
+            "Map delete",
+            _ebpf_map_display_names[map->ebpf_map_definition.type],
+            &map->name,
+            key,
+            map->ebpf_map_definition.key_size);
+    }
+#endif // _DEBUG
+
     if (!(flags & EBPF_MAP_FLAG_HELPER) && (key_size != map->ebpf_map_definition.key_size)) {
         EBPF_LOG_MESSAGE_UINT64_UINT64(
             EBPF_TRACELOG_LEVEL_ERROR,

libs/execution_context/ebpf_program.c

@@ -1559,6 +1559,13 @@ ebpf_program_invoke(
             ebpf_program_entry_point_t function_pointer;
             function_pointer = (ebpf_program_entry_point_t)(current_program->code_or_vm.code.code_pointer);
             *result = (function_pointer)(context);
+#ifdef _DEBUG
+            EBPF_LOG_MESSAGE_UTF8_STRING(
+                EBPF_TRACELOG_LEVEL_INFO,
+                EBPF_TRACELOG_KEYWORD_PROGRAM,
+                "Tail call program",
+                &current_program->parameters.program_name);
+#endif // _DEBUG
         } else {
 #if !defined(CONFIG_BPF_INTERPRETER_DISABLED)
             uint64_t out_value;

libs/shared/ebpf_tracelog.h

@@ -303,6 +303,20 @@ extern "C"
         ebpf_log_message_uint64_uint64(_##trace_level##, _##keyword##, message, value1, value2); \
     }
 
+    void
+    ebpf_log_message_binary(
+        ebpf_tracelog_level_t trace_level,
+        ebpf_tracelog_keyword_t keyword,
+        _In_z_ const char* message,
+        _In_z_ const char* type,
+        _In_ const cxplat_utf8_string_t* name,
+        const void* data,
+        uint32_t data_size);
+#define EBPF_LOG_MESSAGE_BINARY(trace_level, keyword, message, type, name, data, data_size)            \
+    if (TraceLoggingProviderEnabled(ebpf_tracelog_provider, trace_level, keyword)) {                   \
+        ebpf_log_message_binary(_##trace_level##, _##keyword##, message, type, name, data, data_size); \
+    }
+
     void
     ebpf_log_message_error(
         ebpf_tracelog_level_t trace_level,

libs/shared/tracelog.c

@@ -976,6 +976,89 @@ __declspec(noinline) void ebpf_log_message_uint64_uint64(
     }
 }
 
+#define _EBPF_LOG_MESSAGE_BINARY(trace_level, keyword, message, type, name, data, data_size)             \
+    TraceLoggingWrite(                                                                                   \
+        ebpf_tracelog_provider,                                                                          \
+        EBPF_TRACELOG_EVENT_GENERIC_MESSAGE,                                                             \
+        TraceLoggingLevel((trace_level)),                                                                \
+        TraceLoggingKeyword((keyword)),                                                                  \
+        TraceLoggingString((message), "Message"),                                                        \
+        TraceLoggingString((type), "Type"),                                                              \
+        TraceLoggingCountedUtf8String((const char*)(name)->value, (unsigned long)(name)->length, #name), \
+        TraceLoggingBinary((data), (data_size)));
+#define EBPF_LOG_MESSAGE_BINARY_KEYWORD_SWITCH(trace_level, message, type, name, data, data_size)                 \
+    switch (keyword) {                                                                                            \
+    CASE_FUNCTION_ENTRY_EXIT:                                                                                     \
+        _EBPF_LOG_MESSAGE_BINARY(trace_level, KEYWORD_FUNCTION_ENTRY_EXIT, message, type, name, data, data_size); \
+        break;                                                                                                    \
+    CASE_BASE:                                                                                                    \
+        _EBPF_LOG_MESSAGE_BINARY(trace_level, KEYWORD_BASE, message, type, name, data, data_size);                \
+        break;                                                                                                    \
+    CASE_ERROR:                                                                                                   \
+        _EBPF_LOG_MESSAGE_BINARY(trace_level, KEYWORD_ERROR, message, type, name, data, data_size);               \
+        break;                                                                                                    \
+    CASE_EPOCH:                                                                                                   \
+        _EBPF_LOG_MESSAGE_BINARY(trace_level, KEYWORD_EPOCH, message, type, name, data, data_size);               \
+        break;                                                                                                    \
+    CASE_CORE:                                                                                                    \
+        _EBPF_LOG_MESSAGE_BINARY(trace_level, KEYWORD_CORE, message, type, name, data, data_size);                \
+        break;                                                                                                    \
+    CASE_LINK:                                                                                                    \
+        _EBPF_LOG_MESSAGE_BINARY(trace_level, KEYWORD_LINK, message, type, name, data, data_size);                \
+        break;                                                                                                    \
+    CASE_MAP:                                                                                                     \
+        _EBPF_LOG_MESSAGE_BINARY(trace_level, KEYWORD_MAP, message, type, name, data, data_size);                 \
+        break;                                                                                                    \
+    CASE_PROGRAM:                                                                                                 \
+        _EBPF_LOG_MESSAGE_BINARY(trace_level, KEYWORD_PROGRAM, message, type, name, data, data_size);             \
+        break;                                                                                                    \
+    CASE_API:                                                                                                     \
+        _EBPF_LOG_MESSAGE_BINARY(trace_level, KEYWORD_API, message, type, name, data, data_size);                 \
+        break;                                                                                                    \
+    CASE_PRINTK:                                                                                                  \
+        _EBPF_LOG_MESSAGE_BINARY(trace_level, KEYWORD_PRINTK, message, type, name, data, data_size);              \
+        break;                                                                                                    \
+    CASE_NATIVE:                                                                                                  \
+        _EBPF_LOG_MESSAGE_BINARY(trace_level, KEYWORD_NATIVE, message, type, name, data, data_size);              \
+        break;                                                                                                    \
+    default:                                                                                                      \
+        ebpf_assert(!"Invalid keyword");                                                                          \
+        break;                                                                                                    \
+    }
+__declspec(noinline) void ebpf_log_message_binary(
+    ebpf_tracelog_level_t trace_level,
+    ebpf_tracelog_keyword_t keyword,
+    _In_z_ const char* message,
+    _In_z_ const char* type,
+    _In_ const cxplat_utf8_string_t* name,
+    const void* data,
+    uint32_t data_size)
+{
+    switch (trace_level) {
+    CASE_LOG_ALWAYS:
+        EBPF_LOG_MESSAGE_BINARY_KEYWORD_SWITCH(LEVEL_LOG_ALWAYS, message, type, name, data, data_size);
+        break;
+    CASE_CRITICAL:
+        EBPF_LOG_MESSAGE_BINARY_KEYWORD_SWITCH(LEVEL_CRITICAL, message, type, name, data, data_size);
+        break;
+    CASE_LEVEL_ERROR:
+        EBPF_LOG_MESSAGE_BINARY_KEYWORD_SWITCH(LEVEL_ERROR, message, type, name, data, data_size);
+        break;
+    CASE_WARNING:
+        EBPF_LOG_MESSAGE_BINARY_KEYWORD_SWITCH(LEVEL_WARNING, message, type, name, data, data_size);
+        break;
+    CASE_INFO:
+        EBPF_LOG_MESSAGE_BINARY_KEYWORD_SWITCH(LEVEL_INFO, message, type, name, data, data_size);
+        break;
+    CASE_VERBOSE:
+        EBPF_LOG_MESSAGE_BINARY_KEYWORD_SWITCH(LEVEL_VERBOSE, message, type, name, data, data_size);
+        break;
+    default:
+        ebpf_assert(!"Invalid trace level");
+        break;
+    }
+}
+
 #define _EBPF_LOG_MESSAGE_ERROR(trace_level, keyword, message, error) \
     TraceLoggingWrite(                                                \
         ebpf_tracelog_provider,                                       \