mirror of
https://github.com/RIOT-OS/RIOT.git
synced 2024-12-29 04:50:03 +01:00
382 lines
11 KiB
C
382 lines
11 KiB
C
/*
|
|
* Copyright (C) 2020 Freie Universität Berlin,
|
|
*
|
|
* This file is subject to the terms and conditions of the GNU Lesser
|
|
* General Public License v2.1. See the file LICENSE in the top level
|
|
* directory for more details.
|
|
*/
|
|
|
|
/**
|
|
* @ingroup tests
|
|
* @{
|
|
*
|
|
* @file
|
|
* @brief testing ztimer_rmutex_lock_timeout function
|
|
*
|
|
*
|
|
* @author Julian Holzwarth <julian.holzwarth@fu-berlin.de>
|
|
*
|
|
*/
|
|
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include "shell.h"
|
|
#include "ztimer.h"
|
|
#include "thread.h"
|
|
#include "msg.h"
|
|
#include "irq.h"
|
|
|
|
/* timeout at one millisecond (1000 us) to make sure it does not spin. */
|
|
#define LONG_RMUTEX_TIMEOUT 1000
|
|
|
|
/* timeout set to 1us */
|
|
#define SHORT_RMUTEX_TIMEOUT (1)
|
|
|
|
/**
|
|
* Forward declarations
|
|
*/
|
|
static int cmd_test_ztimer_rmutex_lock_timeout_long_unlocked(int argc,
|
|
char **argv);
|
|
static int cmd_test_ztimer_rmutex_lock_timeout_long_locked(int argc,
|
|
char **argv);
|
|
static int cmd_test_ztimer_rmutex_lock_timeout_low_prio_thread(
|
|
int argc, char **argv);
|
|
|
|
static int cmd_test_ztimer_rmutex_lock_timeout_short_unlocked(int argc,
|
|
char **argv);
|
|
static int cmd_test_ztimer_rmutex_lock_timeout_short_locked(int argc,
|
|
char **argv);
|
|
|
|
#define error_wrong_variables "Error: rmutex wrong variables in struct"
|
|
#define error_rmutex_taken "Error: rmutex taken"
|
|
#define error_timeout "Error: rmutex timed out"
|
|
#define shell_help_output "See main.c"
|
|
|
|
/**
|
|
* @brief List of command for this application.
|
|
*/
|
|
static const shell_command_t shell_commands[] = {
|
|
{ "t1", shell_help_output,
|
|
cmd_test_ztimer_rmutex_lock_timeout_long_unlocked, },
|
|
{ "t2", shell_help_output,
|
|
cmd_test_ztimer_rmutex_lock_timeout_long_locked, },
|
|
{ "t3", shell_help_output,
|
|
cmd_test_ztimer_rmutex_lock_timeout_low_prio_thread, },
|
|
{ "t4", shell_help_output,
|
|
cmd_test_ztimer_rmutex_lock_timeout_short_unlocked, },
|
|
{ "t5", shell_help_output,
|
|
cmd_test_ztimer_rmutex_lock_timeout_short_locked, },
|
|
{ NULL, NULL, NULL }
|
|
};
|
|
|
|
/* main Thread PID */
|
|
static kernel_pid_t main_thread_pid;
|
|
|
|
/**
|
|
* @brief stack for
|
|
* cmd_test_ztimer_rmutex_lock_timeout_low_prio_thread
|
|
*/
|
|
static char t_stack[THREAD_STACKSIZE_SMALL];
|
|
|
|
/**
|
|
* @brief send message and suicide thread
|
|
*
|
|
* This function will send a message to a thread without yielding
|
|
* and terminates the calling thread. This can be used to wakeup a
|
|
* thread and terminating yourself.
|
|
* This function calls sched_task_exit()
|
|
*
|
|
* @param[in] m Pointer to preallocated @ref msg_t structure, must
|
|
* not be NULL.
|
|
* @param[in] target_pid PID of target thread
|
|
*
|
|
*/
|
|
static NORETURN void msg_send_sched_task_exit(msg_t *m, kernel_pid_t target_pid)
|
|
{
|
|
(void)irq_disable();
|
|
msg_send_int(m, target_pid);
|
|
sched_task_exit();
|
|
}
|
|
|
|
/**
|
|
* @brief this thread locks a rmutex
|
|
*/
|
|
static void *lock_rmutex_thread(void *arg)
|
|
{
|
|
rmutex_t *test_rmutex = (rmutex_t *)arg;
|
|
|
|
rmutex_lock(test_rmutex);
|
|
return NULL;
|
|
}
|
|
|
|
/**
|
|
* @brief thread function for
|
|
* cmd_test_ztimer_rmutex_lock_timeout_low_prio_thread
|
|
*/
|
|
void *test_thread(void *arg)
|
|
{
|
|
rmutex_t *test_rmutex = (rmutex_t *)arg;
|
|
msg_t msg;
|
|
|
|
rmutex_lock(test_rmutex);
|
|
thread_wakeup(main_thread_pid);
|
|
|
|
rmutex_unlock(test_rmutex);
|
|
|
|
msg_send_sched_task_exit(&msg, main_thread_pid);
|
|
}
|
|
|
|
/**
|
|
* @brief shell command to test ztimer_rmutex_lock_timeout
|
|
*
|
|
* the rmutex is not locked before the function call and
|
|
* the timer long. Meaning the timer will get removed
|
|
* before triggering.
|
|
*
|
|
* @param[in] argc Number of arguments
|
|
* @param[in] argv Array of arguments
|
|
*
|
|
* @return 0 on success
|
|
*/
|
|
static int cmd_test_ztimer_rmutex_lock_timeout_long_unlocked(int argc,
|
|
char **argv)
|
|
{
|
|
(void)argc;
|
|
(void)argv;
|
|
|
|
rmutex_t test_rmutex = RMUTEX_INIT;
|
|
|
|
if (ztimer_rmutex_lock_timeout(ZTIMER_USEC, &test_rmutex, LONG_RMUTEX_TIMEOUT) == 0) {
|
|
/* rmutex has to be locked once */
|
|
if (atomic_load_explicit(&test_rmutex.owner,
|
|
memory_order_relaxed) == thread_getpid() &&
|
|
test_rmutex.refcount == 1 &&
|
|
mutex_trylock(&test_rmutex.mutex) == 0) {
|
|
puts("OK");
|
|
}
|
|
else {
|
|
puts(error_wrong_variables);
|
|
}
|
|
}
|
|
else {
|
|
puts(error_timeout);
|
|
}
|
|
/* to make the test easier to read */
|
|
printf("\n");
|
|
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* @brief shell command to test ztimer_rmutex_lock_timeout
|
|
*
|
|
* the rmutex is locked from another thread before the
|
|
* function call and the timer is long.
|
|
* Meaning the timer will trigger
|
|
* and remove the thread from the rmutex waiting list.
|
|
* To loc
|
|
*
|
|
* @param[in] argc Number of arguments
|
|
* @param[in] argv Array of arguments
|
|
*
|
|
* @return 0 on success
|
|
*/
|
|
static int cmd_test_ztimer_rmutex_lock_timeout_long_locked(int argc,
|
|
char **argv)
|
|
{
|
|
(void)argc;
|
|
(void)argv;
|
|
|
|
rmutex_t test_rmutex = RMUTEX_INIT;
|
|
|
|
/* lock rmutex from different thread */
|
|
kernel_pid_t second_t_pid = thread_create( t_stack, sizeof(t_stack),
|
|
THREAD_PRIORITY_MAIN - 1,
|
|
THREAD_CREATE_STACKTEST,
|
|
lock_rmutex_thread,
|
|
(void *)&test_rmutex,
|
|
"lock_thread");
|
|
|
|
if (ztimer_rmutex_lock_timeout(ZTIMER_USEC, &test_rmutex, LONG_RMUTEX_TIMEOUT) == 0) {
|
|
puts(error_rmutex_taken);
|
|
}
|
|
else {
|
|
/* rmutex has to be locked once */
|
|
if (atomic_load_explicit(&test_rmutex.owner,
|
|
memory_order_relaxed) == second_t_pid &&
|
|
test_rmutex.refcount == 1 &&
|
|
mutex_trylock(&test_rmutex.mutex) == 0) {
|
|
puts("OK");
|
|
}
|
|
else {
|
|
puts(error_wrong_variables);
|
|
}
|
|
}
|
|
/* to make the test easier to read */
|
|
printf("\n");
|
|
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* @brief shell command to test ztimer_rmutex_lock_timeout
|
|
*
|
|
* This function will create a new thread with lower prio
|
|
* than the main thread (this function should be called from
|
|
* the main thread). The new thread will get a rmutex and will
|
|
* lock it. This function (main thread) calls ztimer_rmutex_lock_timeout.
|
|
* The other thread will then unlock the rmutex. The main
|
|
* thread gets the rmutex and wakes up. The timer will not
|
|
* trigger because the main threads gets the rmutex.
|
|
*
|
|
* @param[in] argc Number of arguments
|
|
* @param[in] argv Array of arguments
|
|
*
|
|
* @return 0 on success
|
|
*/
|
|
static int cmd_test_ztimer_rmutex_lock_timeout_low_prio_thread(
|
|
int argc, char **argv)
|
|
{
|
|
(void)argc;
|
|
(void)argv;
|
|
|
|
main_thread_pid = thread_getpid();
|
|
rmutex_t test_rmutex = RMUTEX_INIT;
|
|
|
|
kernel_pid_t second_t_pid = thread_create( t_stack, sizeof(t_stack),
|
|
THREAD_PRIORITY_MAIN + 1,
|
|
THREAD_CREATE_STACKTEST,
|
|
test_thread,
|
|
(void *)&test_rmutex,
|
|
"test_thread");
|
|
(void)second_t_pid;
|
|
thread_sleep();
|
|
|
|
if (ztimer_rmutex_lock_timeout(ZTIMER_USEC, &test_rmutex, LONG_RMUTEX_TIMEOUT) == 0) {
|
|
/* rmutex has to be locked once */
|
|
if (atomic_load_explicit(&test_rmutex.owner,
|
|
memory_order_relaxed) == thread_getpid() &&
|
|
test_rmutex.refcount == 1 &&
|
|
mutex_trylock(&test_rmutex.mutex) == 0) {
|
|
puts("OK");
|
|
}
|
|
else {
|
|
puts(error_wrong_variables);
|
|
}
|
|
}
|
|
else {
|
|
puts(error_timeout);
|
|
}
|
|
|
|
/* to end the created thread */
|
|
msg_t msg;
|
|
msg_receive(&msg);
|
|
|
|
/* to make the test easier to read */
|
|
printf("\n");
|
|
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* @brief shell command to test ztimer_rmutex_lock_timeout when spinning
|
|
*
|
|
* The rmutex is locked before the function call and
|
|
* the timer long. Meaning the timer will trigger before
|
|
* ztimer_rmutex_lock_timeout tries to acquire the rmutex.
|
|
*
|
|
* @param[in] argc Number of arguments
|
|
* @param[in] argv Array of arguments
|
|
*
|
|
* @return 0 on success
|
|
*/
|
|
static int cmd_test_ztimer_rmutex_lock_timeout_short_locked(int argc,
|
|
char **argv)
|
|
{
|
|
(void)argc;
|
|
(void)argv;
|
|
|
|
rmutex_t test_rmutex = RMUTEX_INIT;
|
|
|
|
kernel_pid_t second_t_pid = thread_create( t_stack, sizeof(t_stack),
|
|
THREAD_PRIORITY_MAIN - 1,
|
|
THREAD_CREATE_STACKTEST,
|
|
lock_rmutex_thread,
|
|
(void *)&test_rmutex,
|
|
"lock_thread");
|
|
|
|
if (ztimer_rmutex_lock_timeout(ZTIMER_USEC, &test_rmutex, SHORT_RMUTEX_TIMEOUT) == 0) {
|
|
puts(error_rmutex_taken);
|
|
}
|
|
else {
|
|
/* rmutex has to be locked once */
|
|
if (atomic_load_explicit(&test_rmutex.owner,
|
|
memory_order_relaxed) == second_t_pid &&
|
|
test_rmutex.refcount == 1 &&
|
|
mutex_trylock(&test_rmutex.mutex) == 0) {
|
|
puts("OK");
|
|
}
|
|
else {
|
|
puts(error_wrong_variables);
|
|
}
|
|
}
|
|
/* to make the test easier to read */
|
|
printf("\n");
|
|
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* @brief shell command to test ztimer_rmutex_lock_timeout when spinning
|
|
*
|
|
* the rmutex is not locked before the function is called and
|
|
* the timer is short. Meaning the timer will trigger before
|
|
* ztimer_rmutex_lock_timeout tries to acquire the rmutex.
|
|
*
|
|
* @param[in] argc Number of arguments
|
|
* @param[in] argv Array of arguments
|
|
*
|
|
* @return 0 on success
|
|
*/
|
|
static int cmd_test_ztimer_rmutex_lock_timeout_short_unlocked(int argc,
|
|
char **argv)
|
|
{
|
|
(void)argc;
|
|
(void)argv;
|
|
|
|
rmutex_t test_rmutex = RMUTEX_INIT;
|
|
|
|
if (ztimer_rmutex_lock_timeout(ZTIMER_USEC, &test_rmutex, SHORT_RMUTEX_TIMEOUT) == 0) {
|
|
/* rmutex has to be locked once */
|
|
if (atomic_load_explicit(&test_rmutex.owner,
|
|
memory_order_relaxed) == thread_getpid() &&
|
|
test_rmutex.refcount == 1 &&
|
|
mutex_trylock(&test_rmutex.mutex) == 0) {
|
|
puts("OK");
|
|
}
|
|
else {
|
|
puts(error_wrong_variables);
|
|
}
|
|
}
|
|
else {
|
|
puts(error_timeout);
|
|
}
|
|
/* to make the test easier to read */
|
|
printf("\n");
|
|
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* @brief main function starting shell
|
|
*
|
|
* @return 0 on success
|
|
*/
|
|
int main(void)
|
|
{
|
|
char line_buf[SHELL_DEFAULT_BUFSIZE];
|
|
shell_run(shell_commands, line_buf, SHELL_DEFAULT_BUFSIZE);
|
|
|
|
return 0;
|
|
}
|