rt-thread/components/drivers/smp_call/utest/smp_004_tc.c

/*
 * Copyright (c) 2006-2024 RT-Thread Development Team
 *
 * SPDX-License-Identifier: Apache-2.0
 *
 * Change Logs:
 * Date           Author       Notes
 * 2024/10/28     Shell        Added smp.smoke
 * 2025/12/3      ChuanN-sudo  add standardized utest documentation block
 * 2025/12/9      ChuanN-sudo  fix: initialize current_mask variable
 */

/**
 * Test Case Name: SMP Call Smoke 004 Test
 *
 * Test Objectives:
 * - Validate SMP call mechanism is re-entrant.
 * - Test rt_smp_call_request robustness from interrupt context.
 * - Ensure system stability under nested Inter-Processor Interrupts scenarios from multiple cores.
 * - Test core APIs: rt_smp_call_request(), rt_smp_call_req_init(), rt_smp_request_wait_freed(), rt_smp_call_cpu_mask()
 *
 * Test Scenarios:
 * - Pre-initialized 2D array of rt_smp_call_req objects.
 * - Worker thread triggers primary Inter-Processor Interrupts to another CPU.
 * - Primary handler fires secondary Inter-Processor Interrupts to all other CPUs.
 * - Secondary handlers update shared bitmask.
 * - Worker thread polls bitmask until all secondary Inter-Processor Interrupts complete.
 *
 * Verification Metrics:
 * - Bitmask must match expected value.
 * - Callbacks execute in interrupt-disabled context.
 * - rt_smp_call_request from ISR returns no error.
 *
 * Dependencies:
 * - Hardware requirements:  QEMU emulator or any multi-core hardware platform that supports RT-Thread.
 * - Software configuration:
 *     - RT_USING_UTEST must be enabled (select "RT-Thread Utestcases" in menuconfig).
 *     - RT_UTEST_SMP_CALL_FUNC must be enabled(enable via:  RT-Thread Utestcases -> Kernel Components -> Drivers -> SMP-Call Test -> SMP-Call Smoke Test).
 * - Environmental Assumptions: System scheduler and SMP services working normally.
 *
 * Expected Results:
 * - Progress logs: A series of characters (0-N) indicating which worker's callbacks are executing.
 * - Final output: "[ PASSED ] [ result ] testcase (components.drivers.smp_call.smoke_004)"
 */

#include <rtdevice.h>
#include <utest.h>
#include <utest_assert.h>
#include <smp_call.h>

#define PERCPU_TEST_COUNT 10000
#define NEWLINE_ON 80
#define MAX_RETRIES (RT_TICK_PER_SECOND)

static struct rt_semaphore _utestd_exited;
static rt_thread_t _utestd[RT_CPUS_NR];
static rt_atomic_t _entry_counts[RT_CPUS_NR];
static struct rt_smp_call_req _callreq_data[RT_CPUS_NR][RT_CPUS_NR];
static rt_ubase_t _masks_data[RT_CPUS_NR];
static RT_DEFINE_SPINLOCK(_test_data_lock);

static void _logging_progress(char id)
{
    static rt_atomic_t counts;
    rt_ubase_t old;

    rt_kprintf("%c", id);
    old = rt_atomic_add(&counts, 1);
    if (old % NEWLINE_ON == 0)
    {
        rt_kputs("\n");
    }
}

static void _reentr_isr_cb(void *param)
{
    rt_ubase_t *maskp;
    int  oncpu;

    if (!rt_hw_interrupt_is_disabled())
    {
        /* SYNC.004 */
        uassert_true(0);
    }

    rt_spin_lock(&_test_data_lock);

    oncpu   = rt_hw_cpu_id();
    maskp   = (rt_ubase_t *)param;
    *maskp  |= (1 << oncpu);

    rt_spin_unlock(&_test_data_lock);

    _logging_progress('0' + (maskp - _masks_data));
}

static void _test_smp_call_isr(void *param)
{
    rt_err_t error;
    rt_ubase_t iter, oncpu = (rt_ubase_t)param;
    struct rt_smp_call_req *callreqp = _callreq_data[oncpu];

    if (rt_hw_cpu_id() != oncpu)
    {
        /* SYNC.004 */
        uassert_true(0);
    }

    if (!rt_hw_interrupt_is_disabled())
    {
        /* SYNC.004, PRIV.001 */
        uassert_true(0);
    }

    rt_smp_for_each_remote_cpu(iter, oncpu)
    {
        error = rt_smp_call_request(iter, SMP_CALL_NO_LOCAL, &callreqp[iter]);
        if (error)
        {
            /* SYNC.002 */
            uassert_false(error);
        }
    }
}

static rt_ubase_t _wait_for_update(rt_ubase_t *maskp, rt_ubase_t exp, int cpuid, rt_thread_t curthr)
{
    rt_ubase_t level, current_mask = 0;

    for (size_t i = cpuid; i < RT_CPUS_NR; i++)
    {
        rt_thread_control(curthr, RT_THREAD_CTRL_BIND_CPU, (void *)(i % RT_CPUS_NR));
    }

    for (size_t i = 0; i < MAX_RETRIES; i++)
    {
        level = rt_spin_lock_irqsave(&_test_data_lock);
        current_mask = *maskp;
        rt_spin_unlock_irqrestore(&_test_data_lock, level);

        if (current_mask == exp)
        {
            break;
        }
        rt_thread_delay(1);
    }

    return current_mask;
}
static void _utestd_entry(void *oncpu_param)
{
    rt_thread_t curthr = rt_thread_self();
    rt_ubase_t oncpu = (rt_ubase_t)oncpu_param;
    rt_ubase_t worker_id = (oncpu + 1) % RT_CPUS_NR;
    int cpu_mask = 1ul << worker_id;
    rt_ubase_t req_cpus_mask = ~cpu_mask & RT_ALL_CPU;
    rt_ubase_t *mask_data = &_masks_data[worker_id];
    rt_ubase_t current_mask;
    rt_ubase_t level;

    for (size_t i = 0; i < PERCPU_TEST_COUNT; i++)
    {
        rt_smp_call_cpu_mask(cpu_mask, _test_smp_call_isr, (void *)worker_id, 0);

        current_mask = _wait_for_update(mask_data, req_cpus_mask, worker_id, curthr);
        if (current_mask != req_cpus_mask)
        {
            LOG_I("current mask 0x%x, last fetch 0x%x", *mask_data, current_mask);

            /* MP.002, TARG.001 */
            uassert_true(0);
            break;
        }
        else
        {
            rt_ubase_t iter;
            level = rt_spin_lock_irqsave(&_test_data_lock);
            *mask_data = 0;
            rt_spin_unlock_irqrestore(&_test_data_lock, level);

            rt_smp_for_each_remote_cpu(iter, worker_id)
            {
                rt_smp_request_wait_freed(&_callreq_data[worker_id][iter]);
            }
        }
    }

    rt_sem_release(&_utestd_exited);
}

static void _test_reentr_isr_main(void)
{
    for (size_t i = 0; i < RT_CPUS_NR; i++)
    {
        rt_thread_startup(_utestd[i]);
    }

    for (size_t i = 0; i < RT_CPUS_NR; i++)
    {
        rt_sem_take(&_utestd_exited, RT_WAITING_FOREVER);
    }
}

static rt_err_t utest_tc_init(void)
{
    size_t iter_x, iter_y;
    rt_smp_for_each_cpu(iter_x)
    {
        rt_smp_for_each_cpu(iter_y)
        {
            rt_smp_call_req_init(&_callreq_data[iter_x][iter_y],
                                 _reentr_isr_cb, &_masks_data[iter_x]);
        }
    }

    for (size_t i = 0; i < RT_CPUS_NR; i++)
    {
        _masks_data[i] = 0;
        rt_atomic_store(&_entry_counts[i], 0);
        _utestd[i] = rt_thread_create("utestd", _utestd_entry, (void *)i,
                                      UTEST_THR_STACK_SIZE, UTEST_THR_PRIORITY + 1,
                                      20);
        rt_thread_control(_utestd[i], RT_THREAD_CTRL_BIND_CPU, (void *)i);
        uassert_true(_utestd[i] != RT_NULL);
    }

    rt_sem_init(&_utestd_exited, "utestd", 0, RT_IPC_FLAG_PRIO);
    srand(rt_tick_get());

    return RT_EOK;
}

static rt_err_t utest_tc_cleanup(void)
{
    rt_sem_detach(&_utestd_exited);

    return RT_EOK;
}

static void _testcase(void)
{
    UTEST_UNIT_RUN(_test_reentr_isr_main);
}

UTEST_TC_EXPORT(_testcase, "components.drivers.smp_call.smoke_004", utest_tc_init, utest_tc_cleanup, 10);