// Copyright(c) 2017-2020, Intel Corporation
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are met:
//
// * Redistributions of source code must retain the above copyright notice,
// this list of conditions and the following disclaimer.
// * Redistributions in binary form must reproduce the above copyright notice,
// this list of conditions and the following disclaimer in the documentation
// and/or other materials provided with the distribution.
// * Neither the name of Intel Corporation nor the names of its contributors
// may be used to endorse or promote products derived from this software
// without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
// ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
// POSSIBILITY OF SUCH DAMAGE.
extern "C"{
#include "token_list_int.h"
}
#include "gtest/gtest.h"
#include "mock/test_system.h"
#include "xfpga.h"
#include "types_int.h"
#include "opae/mmio.h"
#include "intel-fpga.h"
#include "fpga-dfl.h"
#include "opae/access.h"
#include "linux/ioctl.h"
#include "cstdarg"
#include "error_int.h"
extern "C" {
int xfpga_plugin_initialize(void);
int xfpga_plugin_finalize(void);
}
using namespace opae::testing;
#ifndef BUILD_ASE
/*
* On hardware, the mmio map is a hash table.
*/
static bool mmio_map_is_empty(struct wsid_tracker *root) {
if (!root || (root->n_hash_buckets == 0))
return true;
for (uint32_t i = 0; i < root->n_hash_buckets; i += 1) {
if (root->table[i])
return false;
}
return true;
}
#else
/*
* In ASE, the mmio map is a list.
*/
static bool mmio_map_is_empty(struct wsid_map *root) {
return !root;
}
#endif
#undef FPGA_MSG
#define FPGA_MSG(fmt, ...) \
printf("MOCK " fmt "\n", ## __VA_ARGS__)
int mmio_ioctl(mock_object * m, int request, va_list argp){
int retval = -1;
errno = EINVAL;
UNUSED_PARAM(m);
UNUSED_PARAM(request);
struct fpga_port_region_info *rinfo = va_arg(argp, struct fpga_port_region_info *);
if (!rinfo) {
FPGA_MSG("rinfo is NULL");
goto out_EINVAL;
}
if (rinfo->argsz != sizeof(*rinfo)) {
FPGA_MSG("wrong structure size");
goto out_EINVAL;
}
if (rinfo->index > 1 ) {
FPGA_MSG("unsupported MMIO index");
goto out_EINVAL;
}
if (rinfo->padding != 0) {
FPGA_MSG("unsupported padding");
goto out_EINVAL;
}
rinfo->flags = FPGA_REGION_READ | FPGA_REGION_WRITE | FPGA_REGION_MMAP;
rinfo->size = 0x40000;
rinfo->offset = 0;
retval = 0;
errno = 0;
out:
return retval;
out_EINVAL:
retval = -1;
errno = EINVAL;
goto out;
}
class openclose_c_p
: public ::testing::TestWithParam<std::string> {
protected:
openclose_c_p()
: handle_(nullptr),
tokens_{{nullptr, nullptr}} {}
virtual void SetUp() override {
ASSERT_TRUE(test_platform::exists(GetParam()));
platform_ = test_platform::get(GetParam());
system_ = test_system::instance();
system_->initialize();
system_->prepare_syfs(platform_);
ASSERT_EQ(xfpga_plugin_initialize(), FPGA_OK);
ASSERT_EQ(xfpga_fpgaGetProperties(nullptr, &filter_), FPGA_OK);
ASSERT_EQ(fpgaPropertiesSetObjectType(filter_, FPGA_ACCELERATOR), FPGA_OK);
ASSERT_EQ(xfpga_fpgaEnumerate(&filter_, 1, tokens_.data(), tokens_.size(),
&num_matches_),
FPGA_OK);
}
virtual void TearDown() override {
EXPECT_EQ(fpgaDestroyProperties(&filter_), FPGA_OK);
for (auto &t : tokens_){
if (t) {
EXPECT_EQ(FPGA_OK, xfpga_fpgaDestroyToken(&t));
t = nullptr;
}
}
xfpga_plugin_finalize();
system_->finalize();
}
fpga_handle handle_;
std::array<fpga_token, 2> tokens_;
fpga_properties filter_;
uint32_t num_matches_;
test_platform platform_;
test_system *system_;
};
/**
* @test open_01
*
* @brief When the fpga_handle * parameter to xfpga_fpgaOpen is NULL, the
* function returns FPGA_INVALID_PARAM.
*/
TEST_P(openclose_c_p, open_01) {
fpga_result res;
res = xfpga_fpgaOpen(NULL, NULL, 0);
ASSERT_EQ(FPGA_INVALID_PARAM, res);
}
/**
* @test open_02
*
* @brief When the fpga_token parameter to xfpga_fpgaOpen is NULL, the
* function returns FPGA_INVALID_PARAM.
*/
TEST_P(openclose_c_p, open_02) {
fpga_handle handle_;
ASSERT_EQ(FPGA_INVALID_PARAM, xfpga_fpgaOpen(NULL, &handle_, 0));
}
/**
* @test open_03
*
* @brief When the flags parameter to xfpga_fpgaOpen is invalid, the
* function returns FPGA_INVALID_PARAM.
*
*/
TEST_P(openclose_c_p, open_03) {
ASSERT_EQ(FPGA_INVALID_PARAM, xfpga_fpgaOpen(tokens_[0], NULL, 42));
ASSERT_EQ(FPGA_INVALID_PARAM, xfpga_fpgaOpen(tokens_[0], &handle_, 42));
}
/**
* @test open_04
*
* @brief When the flags parameter to xfpga_fpgaOpen is invalid, the
* function returns FPGA_INVALID_PARAM.
*
*/
TEST_P(openclose_c_p, open_04) {
auto _token = (struct _fpga_token*)tokens_[0];
auto res = xfpga_fpgaOpen(tokens_[0], &handle_, 42);
ASSERT_EQ(FPGA_INVALID_PARAM, res);
// Invalid token magic
_token->magic = 0x123;
res = xfpga_fpgaOpen(tokens_[0], &handle_, FPGA_OPEN_SHARED);
ASSERT_EQ(FPGA_INVALID_PARAM, res);
// Reset token magic
_token->magic = FPGA_TOKEN_MAGIC;
}
/**
* @test open_05
*
* @brief When the flags parameter to xfpga_fpgaOpen is invalid, the
* function returns FPGA_INVALID_PARAM and FPGA_NO_DRIVER.
*
*/
TEST_P(openclose_c_p, open_05) {
fpga_result res;
struct _fpga_token* _token = (struct _fpga_token*)tokens_[0];
// Invalid flag
res = xfpga_fpgaOpen(tokens_[0], &handle_, 42);
ASSERT_EQ(FPGA_INVALID_PARAM, res);
handle_ = nullptr;
// Valid flag
res = xfpga_fpgaOpen(tokens_[0], &handle_, FPGA_OPEN_SHARED);
ASSERT_EQ(FPGA_OK, res);
ASSERT_EQ(FPGA_OK, xfpga_fpgaClose(handle_));
// Invalid token path
strcpy(_token->devpath,"/dev/intel-fpga-fme.01");
res = xfpga_fpgaOpen(tokens_[0], &handle_, FPGA_OPEN_SHARED);
ASSERT_EQ(FPGA_NO_DRIVER, res);
}
/**
* @test open_06
*
* @brief When the flags parameter to xfpga_fpgaOpen is valid,
* but malloc fails. the function returns FPGA_NO_MEMORY.
*
*/
TEST_P(openclose_c_p, open_06) {
system_->invalidate_malloc();
auto res = xfpga_fpgaOpen(tokens_[0], &handle_, 0);
ASSERT_EQ(FPGA_NO_MEMORY, res);
}
/**
* @test close_01
*
* @brief When the flags parameter to xfpga_fpgaOpen is valid,
* but handle fd is invalid. the function returns
* FPGA_INVALID_PARAM.
*
*/
TEST_P(openclose_c_p, close_01) {
int fddev = -1;
auto res = xfpga_fpgaOpen(tokens_[0], &handle_, 0);
ASSERT_EQ(FPGA_OK, res);
struct _fpga_handle* _handle = (struct _fpga_handle*)handle_;
// Invalid handle fd
fddev = _handle->fddev;
_handle->fddev = -1;
res = xfpga_fpgaClose(handle_);
EXPECT_EQ(res, FPGA_INVALID_PARAM);
// Valid handle fd
_handle->fddev = fddev;
res = xfpga_fpgaClose(handle_);
EXPECT_EQ(res, FPGA_OK);
}
/**
* @test invalid_close
*
* @brief When the fpga_handle parameter to fpgaClose is NULL, the
* function returns FPGA_INVALID_PARAM.
*/
TEST_P(openclose_c_p, invalid_close) {
EXPECT_EQ(FPGA_INVALID_PARAM, xfpga_fpgaClose(NULL));
}
/**
* @test close_03
*
* @brief When the flags parameter to xfpga_fpgaOpen is valid, it
* returns FPGA_OK.
* the function returns FPGA_INVALID_PARAM.
*
*/
TEST_P(openclose_c_p, close_03) {
uint64_t * mmio_ptr = nullptr;
auto res = xfpga_fpgaOpen(tokens_[0], &handle_, 0);
ASSERT_EQ(FPGA_OK, res);
// Register valid ioctl
system_->register_ioctl_handler(FPGA_PORT_GET_REGION_INFO, mmio_ioctl);
system_->register_ioctl_handler(DFL_FPGA_PORT_GET_REGION_INFO, mmio_ioctl);
EXPECT_TRUE(mmio_map_is_empty(((struct _fpga_handle*)handle_)->mmio_root));
ASSERT_EQ(FPGA_OK, xfpga_fpgaMapMMIO(handle_, 0, &mmio_ptr));
EXPECT_NE(mmio_ptr,nullptr);
res = xfpga_fpgaClose(handle_);
EXPECT_EQ(res, FPGA_OK);
}
INSTANTIATE_TEST_CASE_P(openclose_c, openclose_c_p,
::testing::ValuesIn(test_platform::platforms({})));
class openclose_c_skx_dcp_p
: public openclose_c_p {};
/**
* @test open_share
*
* @brief When the parameters are valid and the drivers are loaded,
* and the flag FPGA_OPEN_SHARED is given, fpgaOpen on an
* already opened token returns FPGA_OK.
*/
TEST_P(openclose_c_skx_dcp_p, open_share) {
fpga_handle h1 = nullptr;
fpga_handle h2 = nullptr;
EXPECT_EQ(FPGA_OK, xfpga_fpgaOpen(tokens_[0], &h1, FPGA_OPEN_SHARED));
EXPECT_EQ(FPGA_OK, xfpga_fpgaOpen(tokens_[0], &h2, FPGA_OPEN_SHARED));
EXPECT_EQ(FPGA_OK, xfpga_fpgaClose(h1));
EXPECT_EQ(FPGA_OK, xfpga_fpgaClose(h2));
}
INSTANTIATE_TEST_CASE_P(openclose_c_skx_dcp, openclose_c_skx_dcp_p,
::testing::ValuesIn(test_platform::platforms({}, fpga_driver::linux_intel)));
class openclose_c_dfl_p
: public openclose_c_p {};
/**
* @test open_share
*
* @brief When the parameters are valid and the drivers are loaded,
* and the flag FPGA_OPEN_SHARED is given, fpgaOpen on an
* already opened token returns FPGA_BUSY.
*/
TEST_P(openclose_c_dfl_p, open_share) {
fpga_handle h1 = nullptr;
fpga_handle h2 = nullptr;
EXPECT_EQ(FPGA_OK, xfpga_fpgaOpen(tokens_[0], &h1, FPGA_OPEN_SHARED));
EXPECT_EQ(FPGA_BUSY, xfpga_fpgaOpen(tokens_[0], &h2, FPGA_OPEN_SHARED));
EXPECT_EQ(FPGA_OK, xfpga_fpgaClose(h1));
}
INSTANTIATE_TEST_CASE_P(openclose_c_dfl, openclose_c_dfl_p,
::testing::ValuesIn(test_platform::hw_platforms({}, fpga_driver::linux_dfl0)));
/**
* @test invalid_open_close
*
* @brief When the flags parameter to xfpga_fpgaOpen is valid,
* but driver is not loaded. the function returns FPGA_NO_DRIVER.
*
*/
class openclose_c_mock_p
: public ::testing::TestWithParam<std::string> {
protected:
openclose_c_mock_p() {}
};
TEST_P(openclose_c_mock_p, invalid_open_close) {
struct _fpga_token _tok;
fpga_token tok = &_tok;
fpga_handle h;
const std::string sysfs_port = "/sys/class/fpga/intel-fpga-dev.0/intel-fpga-port.0";
const std::string dev_port = "/dev/intel-fpga-port.0";
// token setup
strncpy(_tok.sysfspath, sysfs_port.c_str(), sysfs_port.size() + 1);
strncpy(_tok.devpath, dev_port.c_str(), dev_port.size() + 1);
_tok.magic = FPGA_TOKEN_MAGIC;
_tok.errors = nullptr;
std::string errpath = sysfs_port + "/errors";
build_error_list(errpath.c_str(), &_tok.errors);
#ifdef BUILD_ASE
ASSERT_EQ(FPGA_OK, xfpga_fpgaOpen(tok, &h, 0));
ASSERT_EQ(FPGA_OK, xfpga_fpgaClose(h));
EXPECT_EQ(fpgaDestroyProperties(&filter), FPGA_OK);
EXPECT_EQ(FPGA_OK, xfpga_fpgaDestroyToken(&tok));
#else
EXPECT_EQ(FPGA_NO_DRIVER, xfpga_fpgaOpen(tok, &h, 0));
#endif
}
INSTANTIATE_TEST_CASE_P(openclose_c, openclose_c_mock_p,
::testing::ValuesIn(test_platform::mock_platforms({})));