ebpf_api.h

Go to the documentation of this file.

// Copyright (c) Microsoft Corporation
// SPDX-License-Identifier: MIT
 
#pragma once
 
#include "ebpf_core_structs.h"
#include "ebpf_execution_type.h"
#include "ebpf_program_attach_type_guids.h"
#include "ebpf_result.h"
 
#include <specstrings.h>
#include <stdbool.h>
#include <stdint.h>
 
#ifdef __cplusplus
#include <stdexcept>
#define EBPF_NO_EXCEPT noexcept
extern "C"
{
#else
#define EBPF_NO_EXCEPT
#endif
 
    typedef int32_t fd_t;
    extern __declspec(selectany) const fd_t ebpf_fd_invalid = -1;
    typedef intptr_t ebpf_handle_t;
 
    struct bpf_object;
    struct bpf_program;
    struct bpf_map;
    struct bpf_link;
 
    _Must_inspect_result_ ebpf_result_t
    ebpf_program_query_info(
        fd_t fd,
        _Out_ ebpf_execution_type_t* execution_type,
        _Outptr_result_z_ const char** file_name,
        _Outptr_result_z_ const char** section_name) EBPF_NO_EXCEPT;
 
    typedef struct _ebpf_stat
    {
        struct _ebpf_stat* next;
        _Field_z_ const char* key;
        int value;
    } ebpf_stat_t;
 
    typedef struct _ebpf_section_info
    {
        struct _ebpf_section_info* next;
        _Field_z_ const char* section_name;
        _Field_z_ const char* program_name;
        ebpf_program_type_t program_type;
        ebpf_attach_type_t expected_attach_type;
        size_t raw_data_size;
        _Field_size_(raw_data_size) char* raw_data;
        ebpf_stat_t* stats;
    } ebpf_section_info_t;
 
    _Must_inspect_result_ ebpf_result_t
    ebpf_enumerate_sections(
        _In_z_ const char* file,
        bool verbose,
        _Outptr_result_maybenull_ ebpf_section_info_t** infos,
        _Outptr_result_maybenull_z_ const char** error_message) EBPF_NO_EXCEPT;
 
    void
    ebpf_free_sections(_In_opt_ _Post_invalid_ ebpf_section_info_t* infos) EBPF_NO_EXCEPT;
 
    uint32_t
    ebpf_api_elf_disassemble_section(
        _In_z_ const char* file,
        _In_z_ const char* section,
        _Outptr_result_maybenull_z_ const char** disassembly,
        _Outptr_result_maybenull_z_ const char** error_message) EBPF_NO_EXCEPT;
 
    typedef struct
    {
        int total_unreachable;
        int total_warnings;
        int max_instruction_count;
    } ebpf_api_verifier_stats_t;
 
    _Success_(return == 0) uint32_t ebpf_api_elf_verify_section_from_file(
        _In_z_ const char* file,
        _In_z_ const char* section,
        _In_opt_ const ebpf_program_type_t* program_type,
        bool verbose,
        _Outptr_result_maybenull_z_ const char** report,
        _Outptr_result_maybenull_z_ const char** error_message,
        _Out_opt_ ebpf_api_verifier_stats_t* stats) EBPF_NO_EXCEPT;
 
    _Success_(return == 0) uint32_t ebpf_api_elf_verify_section_from_memory(
        _In_reads_(data_length) const char* data,
        size_t data_length,
        _In_z_ const char* section,
        _In_opt_ const ebpf_program_type_t* program_type,
        bool verbose,
        _Outptr_result_maybenull_z_ const char** report,
        _Outptr_result_maybenull_z_ const char** error_message,
        _Out_opt_ ebpf_api_verifier_stats_t* stats) EBPF_NO_EXCEPT;
 
    void
    ebpf_free_string(_In_opt_ _Post_invalid_ const char* string) EBPF_NO_EXCEPT;
 
    uint32_t
    ebpf_api_unpin_object(const uint8_t* name, uint32_t name_length) EBPF_NO_EXCEPT;
 
    _Must_inspect_result_ ebpf_result_t
    ebpf_object_unpin(_In_z_ const char* path) EBPF_NO_EXCEPT;
 
    _Must_inspect_result_ ebpf_result_t
    ebpf_api_unlink_program(ebpf_handle_t link_handle) EBPF_NO_EXCEPT;
 
    _Must_inspect_result_ ebpf_result_t
    ebpf_api_close_handle(ebpf_handle_t handle) EBPF_NO_EXCEPT;
 
    _Must_inspect_result_ ebpf_result_t
    ebpf_api_get_pinned_map_info(
        _Out_ uint16_t* map_count,
        _Outptr_result_buffer_maybenull_(*map_count) ebpf_map_info_t** map_info) EBPF_NO_EXCEPT;
 
    void
    ebpf_api_map_info_free(
        uint16_t map_count,
        _In_opt_count_(map_count) _Post_ptr_invalid_ const ebpf_map_info_t* map_info) EBPF_NO_EXCEPT;
 
    ebpf_execution_type_t
    ebpf_object_get_execution_type(_In_ const struct bpf_object* object) EBPF_NO_EXCEPT;
 
    _Must_inspect_result_ ebpf_result_t
    ebpf_object_set_execution_type(_Inout_ struct bpf_object* object, ebpf_execution_type_t execution_type)
        EBPF_NO_EXCEPT;
 
    _Must_inspect_result_ ebpf_result_t
    ebpf_program_attach(
        _In_ const struct bpf_program* program,
        _In_opt_ const ebpf_attach_type_t* attach_type,
        _In_reads_bytes_opt_(attach_params_size) void* attach_parameters,
        size_t attach_params_size,
        _Outptr_ struct bpf_link** link) EBPF_NO_EXCEPT;
 
    _Must_inspect_result_ ebpf_result_t
    ebpf_program_attach_by_fd(
        fd_t program_fd,
        _In_opt_ const ebpf_attach_type_t* attach_type,
        _In_reads_bytes_opt_(attach_parameters_size) void* attach_parameters,
        size_t attach_parameters_size,
        _Outptr_ struct bpf_link** link) EBPF_NO_EXCEPT;
 
    _Must_inspect_result_ ebpf_result_t
    ebpf_link_detach(_Inout_ struct bpf_link* link) EBPF_NO_EXCEPT;
 
    _Must_inspect_result_ ebpf_result_t
    ebpf_program_detach(
        fd_t program_fd,
        _In_ const ebpf_attach_type_t* attach_type,
        _In_reads_bytes_(attach_parameter_size) void* attach_parameter,
        size_t attach_parameter_size) EBPF_NO_EXCEPT;
 
    void
    ebpf_link_close(_Frees_ptr_ struct bpf_link* link) EBPF_NO_EXCEPT;
 
    _Must_inspect_result_ ebpf_result_t
    ebpf_close_fd(fd_t fd) EBPF_NO_EXCEPT;
 
    _Must_inspect_result_ ebpf_result_t
    ebpf_get_program_type_by_name(
        _In_z_ const char* name,
        _Out_ ebpf_program_type_t* program_type,
        _Out_ ebpf_attach_type_t* expected_attach_type) EBPF_NO_EXCEPT;
 
    _Ret_maybenull_z_ const char*
    ebpf_get_program_type_name(_In_ const ebpf_program_type_t* program_type) EBPF_NO_EXCEPT;
 
    _Ret_maybenull_z_ const char*
    ebpf_get_attach_type_name(_In_ const ebpf_attach_type_t* attach_type) EBPF_NO_EXCEPT;
 
    _Must_inspect_result_ ebpf_result_t
    ebpf_get_next_pinned_program_path(
        _In_z_ const char* start_path, _Out_writes_z_(EBPF_MAX_PIN_PATH_LENGTH) char* next_path) EBPF_NO_EXCEPT;
 
    typedef struct _ebpf_program_info ebpf_program_info_t;
 
    _Must_inspect_result_ ebpf_result_t
    ebpf_get_program_info_from_verifier(_Outptr_ const ebpf_program_info_t** program_info) EBPF_NO_EXCEPT;
 
    typedef struct _ebpf_test_run_options
    {
        _Readable_bytes_(data_size_in) const uint8_t* data_in; 
        _Writable_bytes_(data_size_out) uint8_t* data_out;     
        size_t data_size_in;                                   
        size_t data_size_out; 
        _Readable_bytes_(context_size_in) const uint8_t* context_in; 
        _Writable_bytes_(context_size_out) uint8_t* context_out;     
        size_t context_size_in;                                      
        size_t context_size_out; 
        uint64_t return_value;   
        size_t repeat_count;     
        uint64_t duration;       
        uint32_t flags;          
        uint32_t cpu;            
        size_t batch_size;       
    } ebpf_test_run_options_t;
 
    _Must_inspect_result_ ebpf_result_t
    ebpf_program_test_run(fd_t program_fd, _Inout_ ebpf_test_run_options_t* options) EBPF_NO_EXCEPT;
 
#ifdef __cplusplus
}
#endif