3223008829

Build Type

github

Committed by GitHub

Commit Message

<a href="https://github.com/iovisor/ubpf/commit/<a class=hub.com/iovisor/ubpf/commit/7397c13bc18a3ab8ebec69a09e65460d9c44d9ed">7397c13bc<a href="https://github.com/iovisor/ubpf/commit/7397c13bc18a3ab8ebec69a09e65460d9c44d9ed">">Merge </a><a class="double-link" href="https://github.com/iovisor/ubpf/commit/<a class="double-link" href="https://github.com/iovisor/ubpf/commit/521675d189e47ef49880bc8ddd74bf75371e5850">521675d18</a>">521675d18</a><a href="https://github.com/iovisor/ubpf/commit/7397c13bc18a3ab8ebec69a09e65460d9c44d9ed"> into 92f58039c">92f58039c</a>

Pull Request Pull Request #119: Add portable uBPF unit tests that run on Windows / Linux / MacOS

Run Details

59 of 70 new or added lines in 2 files covered. (84.29%)

1824 of 2259 relevant lines covered (80.74%)

245942.11 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

83.33

/ubpf_plugin/ubpf_plugin.cc

// Copyright (c) Microsoft Corporation
// SPDX-License-Identifier: MIT

// This program reads BPF instructions from stdin and memory contents from
// the first agument. It then executes the BPF program and prints the
// value of r0 at the end of execution.
// The program is intended to be used with the bpf conformance test suite.

#include <cstring>
#include <iostream>
#include <memory>
#include <vector>
#include <string>
#include <sstream>

extern "C"
{
#include "ebpf.h"
#include "ubpf.h"
}

#include "test_helpers.h"

/**
 * @brief Read in a string of hex bytes and return a vector of bytes.
 *
 * @param[in] input String containing hex bytes.
 * @return Vector of bytes.
 */
std::vector<uint8_t>
base16_decode(const std::string &input)
{
    std::vector<uint8_t> output;
    std::stringstream ss(input);
    std::string value;
    output.reserve(input.size() / 3);
    while (std::getline(ss, value, ' '))
    {
        try
        {
            output.push_back(static_cast<uint8_t>(std::stoi(value, nullptr, 16)));
        }
        catch (...)
        {
            // Ignore invalid values.
        }
    }
    return output;
}

/**
 * @brief Convert a vector of bytes to a vector of ebpf_inst.
 *
 * @param[in] bytes Vector of bytes.
 * @return Vector of ebpf_inst.
 */
std::vector<ebpf_inst>
bytes_to_ebpf_inst(std::vector<uint8_t> bytes)
{
    std::vector<ebpf_inst> instructions(bytes.size() / sizeof(ebpf_inst));
    memcpy(instructions.data(), bytes.data(), bytes.size());
    return instructions;
}

/**
 * @brief This program reads BPF instructions from stdin and memory contents from
 * the first agument. It then executes the BPF program and prints the
 * value of r0 at the end of execution.
 */
int main(int argc, char **argv)
{
    bool jit = false; // JIT == true, interpreter == false
    std::vector<std::string> args(argv, argv + argc);
    std::string program_string;
    std::string memory_string;
    std::getline(std::cin, program_string);

    // Remove the first argument which is the program name.
    args.erase(args.begin());

    // First parameter is optional memory contents.
    if (args.size() > 0 && !args[0].starts_with("--"))
    {
        memory_string = args[0];
        args.erase(args.begin());
    }
    if (args.size() > 0 && args[0] == "--jit")
    {
        jit = true;
        args.erase(args.begin());
    }
    if (args.size() > 0 && args[0] == "--interpret")
    {
        jit = false;
        args.erase(args.begin());
    }

    if (args.size() > 0 && args[0].size() > 0)
    {
        std::cerr << "Invalid arguments: " << args[0] << std::endl;
        return 1;
    }

    std::vector<ebpf_inst> program = bytes_to_ebpf_inst(base16_decode(program_string));
    std::vector<uint8_t> memory = base16_decode(memory_string);

    std::unique_ptr<ubpf_vm, decltype(&ubpf_destroy)> vm(ubpf_create(), ubpf_destroy);
    char* error = nullptr;

    if (vm == nullptr)
    {
        std::cerr << "Failed to create VM" << std::endl;
        return 1;
    }

    for (auto &[key, value] : helper_functions)
    {
        if (ubpf_register(vm.get(), key, "unnamed", reinterpret_cast<void *>(value)) != 0)
        {
            std::cerr << "Failed to register helper function" << std::endl;
            return 1;
        }
    }

    if (ubpf_set_unwind_function_index(vm.get(), 5) != 0)
    {
        std::cerr << "Failed to set unwind function index" << std::endl;
        return 1;
    }

    if (ubpf_load(vm.get(), program.data(), static_cast<uint32_t>(program.size() * sizeof(ebpf_inst)), &error) != 0)
    {
        std::cerr << "Failed to load program: " << error << std::endl;
        std::cout << "Failed to load code: " << error << std::endl;
        free(error);
        return 1;
    }

    uint64_t actual_result;
    if (jit)
    {
        ubpf_jit_fn fn = ubpf_compile(vm.get(), &error);
        if (fn == nullptr)
        {
            std::cerr << "Failed to compile program: " << error << std::endl;
            std::cout << "Failed to load code: " << error << std::endl;
            free(error);
            return 1;
        }
        actual_result = fn(memory.data(), memory.size());
    }
    else
    {
        if (ubpf_exec(vm.get(), memory.data(), memory.size(), &actual_result) != 0)
        {
            std::cerr << "Failed to execute program" << std::endl;
            return 1;
        }
    }
    std::cout << std::hex << actual_result << std::endl;
    return 0;
}

1	// Copyright (c) Microsoft Corporation
2	// SPDX-License-Identifier: MIT
3
4	// This program reads BPF instructions from stdin and memory contents from
5	// the first agument. It then executes the BPF program and prints the
6	// value of r0 at the end of execution.
7	// The program is intended to be used with the bpf conformance test suite.
8
9	#include <cstring>
10	#include <iostream>
11	#include <memory>
12	#include <vector>
13	#include <string>
14	#include <sstream>
15
16	extern "C"
17	{
18	#include "ebpf.h"
19	#include "ubpf.h"
20	}
21
22	#include "test_helpers.h"
23
24	/**
25	* @brief Read in a string of hex bytes and return a vector of bytes.
26	*
27	* @param[in] input String containing hex bytes.
28	* @return Vector of bytes.
29	*/
30	std::vector<uint8_t>
31	base16_decode(const std::string &input)	4,254,288✔
32	{
33	std::vector<uint8_t> output;	4,254,288✔
34	std::stringstream ss(input);	4,254,288✔
35	std::string value;	4,256,160✔
36	output.reserve(input.size() / 3);	4,254,288✔
37	while (std::getline(ss, value, ' '))	10,631,040✔
38	{
39	try	8,503,420✔
40	{
41	output.push_back(static_cast<uint8_t>(std::stoi(value, nullptr, 16)));	12,754,900✔
42	}	4,251,480✔
43	catch (...)	4,251,940✔
44	{
45	// Ignore invalid values.
46	}	2,125,740✔
47	}
48	return output;	3,744✔
49	}	8,505,768✔
50
51	/**
52	* @brief Convert a vector of bytes to a vector of ebpf_inst.
53	*
54	* @param[in] bytes Vector of bytes.
55	* @return Vector of ebpf_inst.
56	*/
57	std::vector<ebpf_inst>
58	bytes_to_ebpf_inst(std::vector<uint8_t> bytes)	1,404✔
59	{
60	std::vector<ebpf_inst> instructions(bytes.size() / sizeof(ebpf_inst));	1,404✔
61	memcpy(instructions.data(), bytes.data(), bytes.size());	1,404✔
62	return instructions;	936✔
63	}	468✔
64
65	/**
66	* @brief This program reads BPF instructions from stdin and memory contents from
67	* the first agument. It then executes the BPF program and prints the
68	* value of r0 at the end of execution.
69	*/
70	int main(int argc, char **argv)	1,404✔
71	{
72	bool jit = false; // JIT == true, interpreter == false	936✔
73	std::vector<std::string> args(argv, argv + argc);	1,404✔
74	std::string program_string;	2,340✔
75	std::string memory_string;	1,404✔
76	std::getline(std::cin, program_string);	1,404✔
77		468✔
78	// Remove the first argument which is the program name.
79	args.erase(args.begin());	1,404✔
80
81	// First parameter is optional memory contents.
82	if (args.size() > 0 && !args[0].starts_with("--"))	1,404✔
83	{
84	memory_string = args[0];	1,404✔
85	args.erase(args.begin());	1,404✔
86	}	468✔
87	if (args.size() > 0 && args[0] == "--jit")	1,404✔
88	{
89	jit = true;	468✔
90	args.erase(args.begin());	702✔
91	}	234✔
92	if (args.size() > 0 && args[0] == "--interpret")	1,404✔
93	{
94	jit = false;	468✔
95	args.erase(args.begin());	702✔
96	}	234✔
97
98	if (args.size() > 0 && args[0].size() > 0)	1,404✔
99	{
NEW 100	std::cerr << "Invalid arguments: " << args[0] << std::endl;	×
101	return 1;
102	}
103
104	std::vector<ebpf_inst> program = bytes_to_ebpf_inst(base16_decode(program_string));	2,340✔
105	std::vector<uint8_t> memory = base16_decode(memory_string);	2,340✔
106
107	std::unique_ptr<ubpf_vm, decltype(&ubpf_destroy)> vm(ubpf_create(), ubpf_destroy);	2,340✔
108	char* error = nullptr;	1,404✔
109
110	if (vm == nullptr)	1,404✔
111	{
NEW 112	std::cerr << "Failed to create VM" << std::endl;	×
113	return 1;
114	}
115
116	for (auto &[key, value] : helper_functions)	9,828✔
117	{
118	if (ubpf_register(vm.get(), key, "unnamed", reinterpret_cast<void *>(value)) != 0)	8,424✔
119	{
NEW 120	std::cerr << "Failed to register helper function" << std::endl;	×
121	return 1;	936✔
122	}
123	}	2,808✔
124
125	if (ubpf_set_unwind_function_index(vm.get(), 5) != 0)	1,404✔
126	{
NEW 127	std::cerr << "Failed to set unwind function index" << std::endl;	×
128	return 1;
129	}
130
131	if (ubpf_load(vm.get(), program.data(), static_cast<uint32_t>(program.size() * sizeof(ebpf_inst)), &error) != 0)	1,404✔
132	{
133	std::cerr << "Failed to load program: " << error << std::endl;	144✔
134	std::cout << "Failed to load code: " << error << std::endl;	144✔
135	free(error);	144✔
136	return 1;	144✔
137	}
138
139	uint64_t actual_result;	1,260✔
140	if (jit)	1,260✔
141	{
142	ubpf_jit_fn fn = ubpf_compile(vm.get(), &error);	630✔
143	if (fn == nullptr)	630✔
144	{
NEW 145	std::cerr << "Failed to compile program: " << error << std::endl;	×
NEW 146	std::cout << "Failed to load code: " << error << std::endl;	×
NEW 147	free(error);	×
NEW 148	return 1;	×
149	}
150	actual_result = fn(memory.data(), memory.size());	630✔
151	}	210✔
152	else
153	{
154	if (ubpf_exec(vm.get(), memory.data(), memory.size(), &actual_result) != 0)	630✔
155	{
NEW 156	std::cerr << "Failed to execute program" << std::endl;	×
157	return 1;
158	}
159	}
160	std::cout << std::hex << actual_result << std::endl;	1,356✔
161	return 0;	420✔
162	}	6,084✔

iovisor / ubpf / 3223008829

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous