Orange Pi5 kernel

// SPDX-License-Identifier: GPL-2.0-only
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <limits.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
 
#include "debug.h"
#include "tests.h"
#include <api/io.h>
#include <linux/kernel.h>
 
#define TEMPL "/tmp/perf-test-XXXXXX"
 
#define EXPECT_EQUAL(val, expected)                             \
do {								\
<------>if (val != expected) {					\
<------><------>pr_debug("%s:%d: %d != %d\n",			\
<------><------><------>__FILE__, __LINE__, val, expected);	\
<------><------>ret = -1;					\
<------>}							\
} while (0)
 
#define EXPECT_EQUAL64(val, expected)                           \
do {								\
<------>if (val != expected) {					\
<------><------>pr_debug("%s:%d: %lld != %lld\n",		\
<------><------><------>__FILE__, __LINE__, val, expected);	\
<------><------>ret = -1;					\
<------>}							\
} while (0)
 
static int make_test_file(char path[PATH_MAX], const char *contents)
{
<------>ssize_t contents_len = strlen(contents);
<------>int fd;
 
<------>strcpy(path, TEMPL);
<------>fd = mkstemp(path);
<------>if (fd < 0) {
<------><------>pr_debug("mkstemp failed");
<------><------>return -1;
<------>}
<------>if (write(fd, contents, contents_len) < contents_len) {
<------><------>pr_debug("short write");
<------><------>close(fd);
<------><------>unlink(path);
<------><------>return -1;
<------>}
<------>close(fd);
<------>return 0;
}
 
static int setup_test(char path[PATH_MAX], const char *contents,
<------><------>      size_t buf_size, struct io *io)
{
<------>if (make_test_file(path, contents))
<------><------>return -1;
 
<------>io->fd = open(path, O_RDONLY);
<------>if (io->fd < 0) {
<------><------>pr_debug("Failed to open '%s'\n", path);
<------><------>unlink(path);
<------><------>return -1;
<------>}
<------>io->buf = malloc(buf_size);
<------>if (io->buf == NULL) {
<------><------>pr_debug("Failed to allocate memory");
<------><------>close(io->fd);
<------><------>unlink(path);
<------><------>return -1;
<------>}
<------>io__init(io, io->fd, io->buf, buf_size);
<------>return 0;
}
 
static void cleanup_test(char path[PATH_MAX], struct io *io)
{
<------>free(io->buf);
<------>close(io->fd);
<------>unlink(path);
}
 
static int do_test_get_char(const char *test_string, size_t buf_size)
{
<------>char path[PATH_MAX];
<------>struct io io;
<------>int ch, ret = 0;
<------>size_t i;
 
<------>if (setup_test(path, test_string, buf_size, &io))
<------><------>return -1;
 
<------>for (i = 0; i < strlen(test_string); i++) {
<------><------>ch = io__get_char(&io);
 
<------><------>EXPECT_EQUAL(ch, test_string[i]);
<------><------>EXPECT_EQUAL(io.eof, false);
<------>}
<------>ch = io__get_char(&io);
<------>EXPECT_EQUAL(ch, -1);
<------>EXPECT_EQUAL(io.eof, true);
 
<------>cleanup_test(path, &io);
<------>return ret;
}
 
static int test_get_char(void)
{
<------>int i, ret = 0;
<------>size_t j;
 
<------>static const char *const test_strings[] = {
<------><------>"12345678abcdef90",
<------><------>"a\nb\nc\nd\n",
<------><------>"\a\b\t\v\f\r",
<------>};
<------>for (i = 0; i <= 10; i++) {
<------><------>for (j = 0; j < ARRAY_SIZE(test_strings); j++) {
<------><------><------>if (do_test_get_char(test_strings[j], 1 << i))
<------><------><------><------>ret = -1;
<------><------>}
<------>}
<------>return ret;
}
 
static int do_test_get_hex(const char *test_string,
<------><------><------>__u64 val1, int ch1,
<------><------><------>__u64 val2, int ch2,
<------><------><------>__u64 val3, int ch3,
<------><------><------>bool end_eof)
{
<------>char path[PATH_MAX];
<------>struct io io;
<------>int ch, ret = 0;
<------>__u64 hex;
 
<------>if (setup_test(path, test_string, 4, &io))
<------><------>return -1;
 
<------>ch = io__get_hex(&io, &hex);
<------>EXPECT_EQUAL64(hex, val1);
<------>EXPECT_EQUAL(ch, ch1);
 
<------>ch = io__get_hex(&io, &hex);
<------>EXPECT_EQUAL64(hex, val2);
<------>EXPECT_EQUAL(ch, ch2);
 
<------>ch = io__get_hex(&io, &hex);
<------>EXPECT_EQUAL64(hex, val3);
<------>EXPECT_EQUAL(ch, ch3);
 
<------>EXPECT_EQUAL(io.eof, end_eof);
 
<------>cleanup_test(path, &io);
<------>return ret;
}
 
static int test_get_hex(void)
{
<------>int ret = 0;
 
<------>if (do_test_get_hex("12345678abcdef90",
<------><------><------><------>0x12345678abcdef90, -1,
<------><------><------><------>0, -1,
<------><------><------><------>0, -1,
<------><------><------><------>true))
<------><------>ret = -1;
 
<------>if (do_test_get_hex("1\n2\n3\n",
<------><------><------><------>1, '\n',
<------><------><------><------>2, '\n',
<------><------><------><------>3, '\n',
<------><------><------><------>false))
<------><------>ret = -1;
 
<------>if (do_test_get_hex("12345678ABCDEF90;a;b",
<------><------><------><------>0x12345678abcdef90, ';',
<------><------><------><------>0xa, ';',
<------><------><------><------>0xb, -1,
<------><------><------><------>true))
<------><------>ret = -1;
 
<------>if (do_test_get_hex("0x1x2x",
<------><------><------><------>0, 'x',
<------><------><------><------>1, 'x',
<------><------><------><------>2, 'x',
<------><------><------><------>false))
<------><------>ret = -1;
 
<------>if (do_test_get_hex("x1x",
<------><------><------><------>0, -2,
<------><------><------><------>1, 'x',
<------><------><------><------>0, -1,
<------><------><------><------>true))
<------><------>ret = -1;
 
<------>if (do_test_get_hex("10000000000000000000000000000abcdefgh99i",
<------><------><------><------>0xabcdef, 'g',
<------><------><------><------>0, -2,
<------><------><------><------>0x99, 'i',
<------><------><------><------>false))
<------><------>ret = -1;
 
<------>return ret;
}
 
static int do_test_get_dec(const char *test_string,
<------><------><------>__u64 val1, int ch1,
<------><------><------>__u64 val2, int ch2,
<------><------><------>__u64 val3, int ch3,
<------><------><------>bool end_eof)
{
<------>char path[PATH_MAX];
<------>struct io io;
<------>int ch, ret = 0;
<------>__u64 dec;
 
<------>if (setup_test(path, test_string, 4, &io))
<------><------>return -1;
 
<------>ch = io__get_dec(&io, &dec);
<------>EXPECT_EQUAL64(dec, val1);
<------>EXPECT_EQUAL(ch, ch1);
 
<------>ch = io__get_dec(&io, &dec);
<------>EXPECT_EQUAL64(dec, val2);
<------>EXPECT_EQUAL(ch, ch2);
 
<------>ch = io__get_dec(&io, &dec);
<------>EXPECT_EQUAL64(dec, val3);
<------>EXPECT_EQUAL(ch, ch3);
 
<------>EXPECT_EQUAL(io.eof, end_eof);
 
<------>cleanup_test(path, &io);
<------>return ret;
}
 
static int test_get_dec(void)
{
<------>int ret = 0;
 
<------>if (do_test_get_dec("12345678abcdef90",
<------><------><------><------>12345678, 'a',
<------><------><------><------>0, -2,
<------><------><------><------>0, -2,
<------><------><------><------>false))
<------><------>ret = -1;
 
<------>if (do_test_get_dec("1\n2\n3\n",
<------><------><------><------>1, '\n',
<------><------><------><------>2, '\n',
<------><------><------><------>3, '\n',
<------><------><------><------>false))
<------><------>ret = -1;
 
<------>if (do_test_get_dec("12345678;1;2",
<------><------><------><------>12345678, ';',
<------><------><------><------>1, ';',
<------><------><------><------>2, -1,
<------><------><------><------>true))
<------><------>ret = -1;
 
<------>if (do_test_get_dec("0x1x2x",
<------><------><------><------>0, 'x',
<------><------><------><------>1, 'x',
<------><------><------><------>2, 'x',
<------><------><------><------>false))
<------><------>ret = -1;
 
<------>if (do_test_get_dec("x1x",
<------><------><------><------>0, -2,
<------><------><------><------>1, 'x',
<------><------><------><------>0, -1,
<------><------><------><------>true))
<------><------>ret = -1;
 
<------>if (do_test_get_dec("10000000000000000000000000000000000000000000000000000000000123456789ab99c",
<------><------><------><------>123456789, 'a',
<------><------><------><------>0, -2,
<------><------><------><------>99, 'c',
<------><------><------><------>false))
<------><------>ret = -1;
 
<------>return ret;
}
 
int test__api_io(struct test *test __maybe_unused,
<------><------>int subtest __maybe_unused)
{
<------>int ret = 0;
 
<------>if (test_get_char())
<------><------>ret = TEST_FAIL;
<------>if (test_get_hex())
<------><------>ret = TEST_FAIL;
<------>if (test_get_dec())
<------><------>ret = TEST_FAIL;
<------>return ret;
}