u-boot/test/lib/uthread.c

// SPDX-License-Identifier: GPL-2.0+
/*
 * Copyright 2025 Linaro Limited
 *
 * Unit test for uthread
 */

#include <stdbool.h>
#include <test/lib.h>
#include <test/ut.h>
#include <uthread.h>

static int count;

/* A thread entry point */
static void worker(void *arg)
{
	int loops = (int)(unsigned long)arg;
	int i;

	for (i = 0; i < loops; i++) {
		count++;
		uthread_schedule();
	}
}

/*
 * uthread() - testing the uthread API
 *
 * This function creates two threads with the same entry point. The first one
 * receives 5 as an argument, the second one receives 10. The number indicates
 * the number of time the worker thread should loop on uthread_schedule()
 * before returning. The workers increment a global counter each time they loop.
 * As a result the main thread knows how many times it should call
 * uthread_schedule() to let the two threads proceed, and it also knows which
 * value the counter should have at any moment.
 */
static int uthread(struct unit_test_state *uts)
{
	int i;
	int id1, id2;

	count = 0;
	id1 = uthread_grp_new_id();
	ut_assert(id1 != 0);
	id2 = uthread_grp_new_id();
	ut_assert(id2 != 0);
	ut_assert(id1 != id2);
	ut_assertok(uthread_create(NULL, worker, (void *)5, 0, id1));
	ut_assertok(uthread_create(NULL, worker, (void *)10, 0, 0));
	/*
	 * The first call is expected to schedule the first worker, which will
	 * schedule the second one, which will schedule back to the main thread
	 * (here). Therefore count should be 2.
	 */
	ut_assert(uthread_schedule());
	ut_asserteq(2, count);
	ut_assert(!uthread_grp_done(id1));
	/* Four more calls should bring the count to 10 */
	for (i = 0; i < 4; i++) {
		ut_assert(!uthread_grp_done(id1));
		ut_assert(uthread_schedule());
	}
	ut_asserteq(10, count);
	/* This one allows the first worker to exit */
	ut_assert(uthread_schedule());
	/* At this point there should be no runnable thread in group 'id1' */
	ut_assert(uthread_grp_done(id1));
	/* Five more calls for the second worker to finish incrementing  */
	for (i = 0; i < 5; i++)
		ut_assert(uthread_schedule());
	ut_asserteq(15, count);
	/* Plus one call to let the second worker return from its entry point */
	ut_assert(uthread_schedule());
	/* Now both tasks should be done, schedule should return false */
	ut_assert(!uthread_schedule());

	return 0;
}
LIB_TEST(uthread, 0);

struct mw_args {
	struct unit_test_state *uts;
	struct uthread_mutex *m;
	int flag;
};

static int mutex_worker_ret;

static int _mutex_worker(struct mw_args *args)
{
	struct unit_test_state *uts = args->uts;

	ut_asserteq(-EBUSY, uthread_mutex_trylock(args->m));
	ut_assertok(uthread_mutex_lock(args->m));
	args->flag = 1;
	ut_assertok(uthread_mutex_unlock(args->m));

	return 0;
}

static void mutex_worker(void *arg)
{
	mutex_worker_ret = _mutex_worker((struct mw_args *)arg);
}

/*
 * thread_mutex() - testing uthread mutex operations
 *
 */
static int uthread_mutex(struct unit_test_state *uts)
{
	struct uthread_mutex m = UTHREAD_MUTEX_INITIALIZER;
	struct mw_args args = { .uts = uts, .m = &m, .flag = 0 };
	int id;
	int i;

	id = uthread_grp_new_id();
	ut_assert(id != 0);
	/* Take the mutex */
	ut_assertok(uthread_mutex_lock(&m));
	/* Start a thread */
	ut_assertok(uthread_create(NULL, mutex_worker, (void *)&args, 0,
				   id));
	/* Let the thread run for a bit */
	for (i = 0; i < 100; i++)
		ut_assert(uthread_schedule());
	/* Thread should not have set the flag due to the mutex */
	ut_asserteq(0, args.flag);
	/* Release the mutex */
	ut_assertok(uthread_mutex_unlock(&m));
	/* Schedule the thread until it is done */
	while (uthread_schedule())
		;
	/* Now the flag should be set */
	ut_asserteq(1, args.flag);
	/* And the mutex should be available */
	ut_assertok(uthread_mutex_trylock(&m));
	ut_assertok(uthread_mutex_unlock(&m));

	/* Of course no error are expected from the thread routine */
	ut_assertok(mutex_worker_ret);

	return 0;
}
LIB_TEST(uthread_mutex, 0);