lib/unittest/unittest.c - trusty/lk/trusty - Git at Google

 /*
  * Copyright (C) 2018 The Android Open Source Project
  *
  * Permission is hereby granted, free of charge, to any person obtaining
  * a copy of this software and associated documentation files
  * (the "Software"), to deal in the Software without restriction,
  * including without limitation the rights to use, copy, modify, merge,
  * publish, distribute, sublicense, and/or sell copies of the Software,
  * and to permit persons to whom the Software is furnished to do so,
  * subject to the following conditions:
  *
  * The above copyright notice and this permission notice shall be
  * included in all copies or substantial portions of the Software.
  *
  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
  * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
  * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
  * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
  * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  */

 #include <lib/unittest/unittest.h>

 #include <lib/trusty/handle_set.h>
 #include <lib/trusty/ipc.h>
 #include <lib/trusty/ipc_msg.h>
 #include <stddef.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>

 #include <uapi/err.h>

 #define LOCAL_TRACE (0)

 #include <lk/trace.h>

 #define MAX_PORT_BUF_SIZE 4096 /* max size of per port buffer */

 enum test_message_header {
     TEST_PASSED = 0,
     TEST_FAILED = 1,
     TEST_MESSAGE = 2,
     TEST_MESSAGE_HEADER_COUNT = 3,
 };

 static struct handle* ipc_printf_handle;
 static struct mutex unittest_lock = MUTEX_INITIAL_VALUE(unittest_lock);
 static struct handle* unittest_handle_set;
 static thread_t* unittest_thread;

 uint64_t get_current_time_ns(void) {
     return current_time_ns();
 }

 static int send_msg_wait(struct handle* handle, struct ipc_msg_kern* msg) {
     int ret;
     uint32_t event;

     ASSERT(is_mutex_held(&unittest_lock));

     ret = ipc_send_msg(handle, msg);
     if (ret != ERR_NOT_ENOUGH_BUFFER) {
         return ret;
     }

     ret = handle_wait(handle, &event, INFINITE_TIME);
     if (ret < 0) {
         return ret;
     }

     if (event & IPC_HANDLE_POLL_SEND_UNBLOCKED) {
         return ipc_send_msg(handle, msg);
     }

     if (event & IPC_HANDLE_POLL_MSG) {
         return ERR_BUSY;
     }

     if (event & IPC_HANDLE_POLL_HUP) {
         return ERR_CHANNEL_CLOSED;
     }

     return ret;
 }

 /**
  * unittest_printf - Print a message that gets sent back to the client
  * @fmt:    Format string.
  *
  * Print a message that gets sent back to the currently connected client. Should
  * only be called while the run_test function registered with unittest_add runs.
  * The length of the formatted string is limited to 254 bytes.
  *
  * Return: Formatted string length or (negative) error code.
  */
 int unittest_printf(const char* fmt, ...) {
     char buf[256];
     struct iovec_kern tx_iov = {buf, 1};
     struct ipc_msg_kern tx_msg = {1, &tx_iov, 0, NULL};
     va_list ap;
     int ret;
     int slen;

     va_start(ap, fmt);
     /* Format string into buf[1...]. buf[0] contains the message header. */
     ret = vsnprintf(buf + 1, sizeof(buf) - 1, fmt, ap);
     va_end(ap);

     if (ret < 0) {
         return ret;
     }

     /*
      * vsnprintf returns the length of the string it would produce if the buffer
      * was big enough. Compute the actual string length by clamping the return
      * value to the largest string that can fit in the buffer.
      */
     slen = MIN(ret, (int)sizeof(buf) - 1 - 1);

     buf[0] = TEST_MESSAGE;
     tx_iov.iov_len = 1 + slen;
     mutex_acquire(&unittest_lock);
     ret = send_msg_wait(ipc_printf_handle, &tx_msg);
     mutex_release(&unittest_lock);
     if (ret < 0) {
         return ret;
     }

     return slen;
 }

 /**
  * unittest_loop - Thread function handling all kernel unit-tests
  * arg:     Unused thread argument.
  *
  * Wait on handle-set for a client to connect. When a client connects, run the
  * test function for the port the client connected to then sent the test status
  * back to the client. The test function can call unittest_printf to send text
  * back to the client.
  *
  * Return: error code is there was an unexpected error.
  */
 static int unittest_loop(void* arg) {
     int ret;
     struct handle* chandle;
     struct handle_ref evt;
     const uuid_t* unused_uuid_p;
     struct unittest* test;

     LTRACEF("waiting for connection\n");
     for (;;) {
         ret = handle_set_wait(unittest_handle_set, &evt, INFINITE_TIME);
         if (ret < 0) {
             TRACEF("handle_set_wait failed: %d\n", ret);
             break;
         }
         test = evt.cookie;
         LTRACEF("got event (ret=%d): ev=%x handle=%p port=%s\n", ret, evt.emask,
                 evt.handle, test->port_name);
         if (evt.emask & IPC_HANDLE_POLL_READY) {
             /* get connection request */
             ret = ipc_port_accept(evt.handle, &chandle, &unused_uuid_p);
             LTRACEF("accept returned %d\n", ret);
             if (ret >= 0) {
                 char tx_buffer[1];
                 struct iovec_kern tx_iov = {
                         tx_buffer,
                         sizeof(tx_buffer),
                 };
                 struct ipc_msg_kern tx_msg = {1, &tx_iov, 0, NULL};

                 /* then run unittest test */
                 ipc_printf_handle = chandle;
                 tx_buffer[0] = test->run_test(test) ? TEST_PASSED : TEST_FAILED;
                 mutex_acquire(&unittest_lock);
                 ipc_printf_handle = NULL;

                 send_msg_wait(chandle, &tx_msg);
                 mutex_release(&unittest_lock);

                 /* and close it */
                 handle_close(chandle);
             }
         }
     }

     return ret;
 }

 /**
  * unittest_add_locked - Internal helper function to add a kernel unit-test
  * @test:   See unittest_add.
  *
  * unittest_lock must be locked before calling this.
  *
  * Return: See unittest_add.
  */
 static int unittest_add_locked(struct unittest* test) {
     int ret;
     struct handle* phandle;

     ASSERT(is_mutex_held(&unittest_lock));

     if (!unittest_handle_set) {
         unittest_handle_set = handle_set_create();
         if (!unittest_handle_set) {
             ret = ERR_NO_MEMORY;
             goto err_handle_set_create;
         }
     }
     ret = ipc_port_create(&kernel_uuid, test->port_name, 1, MAX_PORT_BUF_SIZE,
                           IPC_PORT_ALLOW_NS_CONNECT | IPC_PORT_ALLOW_TA_CONNECT,
                           &phandle);
     if (ret) {
         goto err_port_create;
     }

     ret = ipc_port_publish(phandle);
     if (ret) {
         goto err_port_publish;
     }
     handle_incref(phandle);
     test->_href.handle = phandle;
     test->_href.emask = ~0U;
     test->_href.cookie = test;
     ret = handle_set_attach(unittest_handle_set, &test->_href);
     if (ret < 0) {
         goto err_handle_set_attach;
     }
     LTRACEF("added port %s handle, %p, to handleset %p\n", test->port_name,
             test->_href.handle, unittest_handle_set);

     if (!unittest_thread) {
         unittest_thread = thread_create("unittest", unittest_loop, NULL,
                                         HIGH_PRIORITY, DEFAULT_STACK_SIZE);
         if (!unittest_thread) {
             ret = ERR_NO_MEMORY;
             goto err_thread_create;
         }
         thread_resume(unittest_thread);
     }
     return 0;

 err_thread_create:
     handle_set_detach_ref(&test->_href);
 err_handle_set_attach:
     handle_decref(phandle);
 err_port_publish:
     handle_close(phandle);
 err_port_create:
 err_handle_set_create:
     TRACEF("Failed to add unittest: %d\n", ret);
     return ret;
 }

 /**
  * unittest_add - Add a kernel unit-test
  * @test:   Test descriptor with port name and callback to start the test when
  *          a client connects to the port. @test is used after unittest_add
  *          returns so it must not be a temporary allocation.
  *
  * Creates a port for @test. when the first test is added, create a handle set
  * and thread that will be shared between all tests.
  *
  * Return: 0 if test was added, error-code otherwise.
  */
 int unittest_add(struct unittest* test) {
     int ret;

     mutex_acquire(&unittest_lock);
     ret = unittest_add_locked(test);
     mutex_release(&unittest_lock);

     return ret;
 }
	/*
	* Copyright (C) 2018 The Android Open Source Project
	*
	* Permission is hereby granted, free of charge, to any person obtaining
	* a copy of this software and associated documentation files
	* (the "Software"), to deal in the Software without restriction,
	* including without limitation the rights to use, copy, modify, merge,
	* publish, distribute, sublicense, and/or sell copies of the Software,
	* and to permit persons to whom the Software is furnished to do so,
	* subject to the following conditions:
	*
	* The above copyright notice and this permission notice shall be
	* included in all copies or substantial portions of the Software.
	*
	* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
	* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
	* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
	* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
	* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
	* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
	* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
	*/

	#include <lib/unittest/unittest.h>

	#include <lib/trusty/handle_set.h>
	#include <lib/trusty/ipc.h>
	#include <lib/trusty/ipc_msg.h>
	#include <stddef.h>
	#include <stdio.h>
	#include <stdlib.h>
	#include <string.h>

	#include <uapi/err.h>

	#define LOCAL_TRACE (0)

	#include <lk/trace.h>

	#define MAX_PORT_BUF_SIZE 4096 /* max size of per port buffer */

	enum test_message_header {
	TEST_PASSED = 0,
	TEST_FAILED = 1,
	TEST_MESSAGE = 2,
	TEST_MESSAGE_HEADER_COUNT = 3,
	};

	static struct handle* ipc_printf_handle;
	static struct mutex unittest_lock = MUTEX_INITIAL_VALUE(unittest_lock);
	static struct handle* unittest_handle_set;
	static thread_t* unittest_thread;

	uint64_t get_current_time_ns(void) {
	return current_time_ns();
	}

	static int send_msg_wait(struct handle* handle, struct ipc_msg_kern* msg) {
	int ret;
	uint32_t event;

	ASSERT(is_mutex_held(&unittest_lock));

	ret = ipc_send_msg(handle, msg);
	if (ret != ERR_NOT_ENOUGH_BUFFER) {
	return ret;
	}

	ret = handle_wait(handle, &event, INFINITE_TIME);
	if (ret < 0) {
	return ret;
	}

	if (event & IPC_HANDLE_POLL_SEND_UNBLOCKED) {
	return ipc_send_msg(handle, msg);
	}

	if (event & IPC_HANDLE_POLL_MSG) {
	return ERR_BUSY;
	}

	if (event & IPC_HANDLE_POLL_HUP) {
	return ERR_CHANNEL_CLOSED;
	}

	return ret;
	}

	/**
	* unittest_printf - Print a message that gets sent back to the client
	* @fmt: Format string.
	*
	* Print a message that gets sent back to the currently connected client. Should
	* only be called while the run_test function registered with unittest_add runs.
	* The length of the formatted string is limited to 254 bytes.
	*
	* Return: Formatted string length or (negative) error code.
	*/
	int unittest_printf(const char* fmt, ...) {
	char buf[256];
	struct iovec_kern tx_iov = {buf, 1};
	struct ipc_msg_kern tx_msg = {1, &tx_iov, 0, NULL};
	va_list ap;
	int ret;
	int slen;

	va_start(ap, fmt);
	/* Format string into buf[1...]. buf[0] contains the message header. */
	ret = vsnprintf(buf + 1, sizeof(buf) - 1, fmt, ap);
	va_end(ap);

	if (ret < 0) {
	return ret;
	}

	/*
	* vsnprintf returns the length of the string it would produce if the buffer
	* was big enough. Compute the actual string length by clamping the return
	* value to the largest string that can fit in the buffer.
	*/
	slen = MIN(ret, (int)sizeof(buf) - 1 - 1);

	buf[0] = TEST_MESSAGE;
	tx_iov.iov_len = 1 + slen;
	mutex_acquire(&unittest_lock);
	ret = send_msg_wait(ipc_printf_handle, &tx_msg);
	mutex_release(&unittest_lock);
	if (ret < 0) {
	return ret;
	}

	return slen;
	}

	/**
	* unittest_loop - Thread function handling all kernel unit-tests
	* arg: Unused thread argument.
	*
	* Wait on handle-set for a client to connect. When a client connects, run the
	* test function for the port the client connected to then sent the test status
	* back to the client. The test function can call unittest_printf to send text
	* back to the client.
	*
	* Return: error code is there was an unexpected error.
	*/
	static int unittest_loop(void* arg) {
	int ret;
	struct handle* chandle;
	struct handle_ref evt;
	const uuid_t* unused_uuid_p;
	struct unittest* test;

	LTRACEF("waiting for connection\n");
	for (;;) {
	ret = handle_set_wait(unittest_handle_set, &evt, INFINITE_TIME);
	if (ret < 0) {
	TRACEF("handle_set_wait failed: %d\n", ret);
	break;
	}
	test = evt.cookie;
	LTRACEF("got event (ret=%d): ev=%x handle=%p port=%s\n", ret, evt.emask,
	evt.handle, test->port_name);
	if (evt.emask & IPC_HANDLE_POLL_READY) {
	/* get connection request */
	ret = ipc_port_accept(evt.handle, &chandle, &unused_uuid_p);
	LTRACEF("accept returned %d\n", ret);
	if (ret >= 0) {
	char tx_buffer[1];
	struct iovec_kern tx_iov = {
	tx_buffer,
	sizeof(tx_buffer),
	};
	struct ipc_msg_kern tx_msg = {1, &tx_iov, 0, NULL};

	/* then run unittest test */
	ipc_printf_handle = chandle;
	tx_buffer[0] = test->run_test(test) ? TEST_PASSED : TEST_FAILED;
	mutex_acquire(&unittest_lock);
	ipc_printf_handle = NULL;

	send_msg_wait(chandle, &tx_msg);
	mutex_release(&unittest_lock);

	/* and close it */
	handle_close(chandle);
	}
	}
	}

	return ret;
	}

	/**
	* unittest_add_locked - Internal helper function to add a kernel unit-test
	* @test: See unittest_add.
	*
	* unittest_lock must be locked before calling this.
	*
	* Return: See unittest_add.
	*/
	static int unittest_add_locked(struct unittest* test) {
	int ret;
	struct handle* phandle;

	ASSERT(is_mutex_held(&unittest_lock));

	if (!unittest_handle_set) {
	unittest_handle_set = handle_set_create();
	if (!unittest_handle_set) {
	ret = ERR_NO_MEMORY;
	goto err_handle_set_create;
	}
	}
	ret = ipc_port_create(&kernel_uuid, test->port_name, 1, MAX_PORT_BUF_SIZE,
	IPC_PORT_ALLOW_NS_CONNECT \| IPC_PORT_ALLOW_TA_CONNECT,
	&phandle);
	if (ret) {
	goto err_port_create;
	}

	ret = ipc_port_publish(phandle);
	if (ret) {
	goto err_port_publish;
	}
	handle_incref(phandle);
	test->_href.handle = phandle;
	test->_href.emask = ~0U;
	test->_href.cookie = test;
	ret = handle_set_attach(unittest_handle_set, &test->_href);
	if (ret < 0) {
	goto err_handle_set_attach;
	}
	LTRACEF("added port %s handle, %p, to handleset %p\n", test->port_name,
	test->_href.handle, unittest_handle_set);

	if (!unittest_thread) {
	unittest_thread = thread_create("unittest", unittest_loop, NULL,
	HIGH_PRIORITY, DEFAULT_STACK_SIZE);
	if (!unittest_thread) {
	ret = ERR_NO_MEMORY;
	goto err_thread_create;
	}
	thread_resume(unittest_thread);
	}
	return 0;

	err_thread_create:
	handle_set_detach_ref(&test->_href);
	err_handle_set_attach:
	handle_decref(phandle);
	err_port_publish:
	handle_close(phandle);
	err_port_create:
	err_handle_set_create:
	TRACEF("Failed to add unittest: %d\n", ret);
	return ret;
	}

	/**
	* unittest_add - Add a kernel unit-test
	* @test: Test descriptor with port name and callback to start the test when
	* a client connects to the port. @test is used after unittest_add
	* returns so it must not be a temporary allocation.
	*
	* Creates a port for @test. when the first test is added, create a handle set
	* and thread that will be shared between all tests.
	*
	* Return: 0 if test was added, error-code otherwise.
	*/
	int unittest_add(struct unittest* test) {
	int ret;

	mutex_acquire(&unittest_lock);
	ret = unittest_add_locked(test);
	mutex_release(&unittest_lock);

	return ret;
	}