// SPDX-License-Identifier: GPL-2.0-only
/*
 * Compile-only tests for common patterns that should not generate false
 * positive errors when compiled with Clang's context analysis.
 */

#include <linux/bit_spinlock.h>
#include <linux/build_bug.h>
#include <linux/local_lock.h>
#include <linux/mutex.h>
#include <linux/percpu.h>
#include <linux/rcupdate.h>
#include <linux/rwsem.h>
#include <linux/seqlock.h>
#include <linux/spinlock.h>
#include <linux/srcu.h>
#include <linux/ww_mutex.h>

/*
 * Test that helper macros work as expected.
 */
static void __used test_common_helpers(void)
{
        BUILD_BUG_ON(context_unsafe(3) != 3); /* plain expression */
        BUILD_BUG_ON(context_unsafe((void)2; 3) != 3); /* does not swallow semi-colon */
        BUILD_BUG_ON(context_unsafe((void)2, 3) != 3); /* does not swallow commas */
        context_unsafe(do { } while (0)); /* works with void statements */
}

#define TEST_SPINLOCK_COMMON(class, type, type_init, type_lock, type_unlock, type_trylock, op)  \
        struct test_##class##_data {                                                            \
                type lock;                                                                      \
                int counter __guarded_by(&lock);                                                \
                int *pointer __pt_guarded_by(&lock);                                            \
        };                                                                                      \
        static void __used test_##class##_init(struct test_##class##_data *d)                   \
        {                                                                                       \
                guard(type_init)(&d->lock);                                                     \
                d->counter = 0;                                                                 \
        }                                                                                       \
        static void __used test_##class(struct test_##class##_data *d)                          \
        {                                                                                       \
                unsigned long flags;                                                            \
                d->pointer++;                                                                   \
                type_lock(&d->lock);                                                            \
                op(d->counter);                                                                 \
                op(*d->pointer);                                                                \
                type_unlock(&d->lock);                                                          \
                type_lock##_irq(&d->lock);                                                      \
                op(d->counter);                                                                 \
                op(*d->pointer);                                                                \
                type_unlock##_irq(&d->lock);                                                    \
                type_lock##_bh(&d->lock);                                                       \
                op(d->counter);                                                                 \
                op(*d->pointer);                                                                \
                type_unlock##_bh(&d->lock);                                                     \
                type_lock##_irqsave(&d->lock, flags);                                           \
                op(d->counter);                                                                 \
                op(*d->pointer);                                                                \
                type_unlock##_irqrestore(&d->lock, flags);                                      \
        }                                                                                       \
        static void __used test_##class##_trylock(struct test_##class##_data *d)                \
        {                                                                                       \
                if (type_trylock(&d->lock)) {                                                   \
                        op(d->counter);                                                         \
                        type_unlock(&d->lock);                                                  \
                }                                                                               \
        }                                                                                       \
        static void __used test_##class##_assert(struct test_##class##_data *d)                 \
        {                                                                                       \
                lockdep_assert_held(&d->lock);                                                  \
                op(d->counter);                                                                 \
        }                                                                                       \
        static void __used test_##class##_guard(struct test_##class##_data *d)                  \
        {                                                                                       \
                { guard(class)(&d->lock);               op(d->counter); }                       \
                { guard(class##_irq)(&d->lock);         op(d->counter); }                       \
                { guard(class##_irqsave)(&d->lock);     op(d->counter); }                       \
        }

#define TEST_OP_RW(x) (x)++
#define TEST_OP_RO(x) ((void)(x))

TEST_SPINLOCK_COMMON(raw_spinlock,
                     raw_spinlock_t,
                     raw_spinlock_init,
                     raw_spin_lock,
                     raw_spin_unlock,
                     raw_spin_trylock,
                     TEST_OP_RW);
static void __used test_raw_spinlock_trylock_extra(struct test_raw_spinlock_data *d)
{
        unsigned long flags;

        data_race(d->counter++); /* no warning */

        if (raw_spin_trylock_irq(&d->lock)) {
                d->counter++;
                raw_spin_unlock_irq(&d->lock);
        }
        if (raw_spin_trylock_irqsave(&d->lock, flags)) {
                d->counter++;
                raw_spin_unlock_irqrestore(&d->lock, flags);
        }
        scoped_cond_guard(raw_spinlock_try, return, &d->lock) {
                d->counter++;
        }
}

TEST_SPINLOCK_COMMON(spinlock,
                     spinlock_t,
                     spinlock_init,
                     spin_lock,
                     spin_unlock,
                     spin_trylock,
                     TEST_OP_RW);
static void __used test_spinlock_trylock_extra(struct test_spinlock_data *d)
{
        unsigned long flags;

        if (spin_trylock_irq(&d->lock)) {
                d->counter++;
                spin_unlock_irq(&d->lock);
        }
        if (spin_trylock_irqsave(&d->lock, flags)) {
                d->counter++;
                spin_unlock_irqrestore(&d->lock, flags);
        }
        scoped_cond_guard(spinlock_try, return, &d->lock) {
                d->counter++;
        }
}

TEST_SPINLOCK_COMMON(write_lock,
                     rwlock_t,
                     rwlock_init,
                     write_lock,
                     write_unlock,
                     write_trylock,
                     TEST_OP_RW);
static void __used test_write_trylock_extra(struct test_write_lock_data *d)
{
        unsigned long flags;

        if (write_trylock_irqsave(&d->lock, flags)) {
                d->counter++;
                write_unlock_irqrestore(&d->lock, flags);
        }
}

TEST_SPINLOCK_COMMON(read_lock,
                     rwlock_t,
                     rwlock_init,
                     read_lock,
                     read_unlock,
                     read_trylock,
                     TEST_OP_RO);

struct test_mutex_data {
        struct mutex mtx;
        int counter __guarded_by(&mtx);
};

static void __used test_mutex_init(struct test_mutex_data *d)
{
        guard(mutex_init)(&d->mtx);
        d->counter = 0;
}

static void __used test_mutex_lock(struct test_mutex_data *d)
{
        mutex_lock(&d->mtx);
        d->counter++;
        mutex_unlock(&d->mtx);
        mutex_lock_io(&d->mtx);
        d->counter++;
        mutex_unlock(&d->mtx);
}

static void __used test_mutex_trylock(struct test_mutex_data *d, atomic_t *a)
{
        if (!mutex_lock_interruptible(&d->mtx)) {
                d->counter++;
                mutex_unlock(&d->mtx);
        }
        if (!mutex_lock_killable(&d->mtx)) {
                d->counter++;
                mutex_unlock(&d->mtx);
        }
        if (mutex_trylock(&d->mtx)) {
                d->counter++;
                mutex_unlock(&d->mtx);
        }
        if (atomic_dec_and_mutex_lock(a, &d->mtx)) {
                d->counter++;
                mutex_unlock(&d->mtx);
        }
}

static void __used test_mutex_assert(struct test_mutex_data *d)
{
        lockdep_assert_held(&d->mtx);
        d->counter++;
}

static void __used test_mutex_guard(struct test_mutex_data *d)
{
        guard(mutex)(&d->mtx);
        d->counter++;
}

static void __used test_mutex_cond_guard(struct test_mutex_data *d)
{
        scoped_cond_guard(mutex_try, return, &d->mtx) {
                d->counter++;
        }
        scoped_cond_guard(mutex_intr, return, &d->mtx) {
                d->counter++;
        }
}

struct test_seqlock_data {
        seqlock_t sl;
        int counter __guarded_by(&sl);
};

static void __used test_seqlock_init(struct test_seqlock_data *d)
{
        guard(seqlock_init)(&d->sl);
        d->counter = 0;
}

static void __used test_seqlock_reader(struct test_seqlock_data *d)
{
        unsigned int seq;

        do {
                seq = read_seqbegin(&d->sl);
                (void)d->counter;
        } while (read_seqretry(&d->sl, seq));
}

static void __used test_seqlock_writer(struct test_seqlock_data *d)
{
        unsigned long flags;

        write_seqlock(&d->sl);
        d->counter++;
        write_sequnlock(&d->sl);

        write_seqlock_irq(&d->sl);
        d->counter++;
        write_sequnlock_irq(&d->sl);

        write_seqlock_bh(&d->sl);
        d->counter++;
        write_sequnlock_bh(&d->sl);

        write_seqlock_irqsave(&d->sl, flags);
        d->counter++;
        write_sequnlock_irqrestore(&d->sl, flags);
}

static void __used test_seqlock_scoped(struct test_seqlock_data *d)
{
        scoped_seqlock_read (&d->sl, ss_lockless) {
                (void)d->counter;
        }
}

struct test_rwsem_data {
        struct rw_semaphore sem;
        int counter __guarded_by(&sem);
};

static void __used test_rwsem_init(struct test_rwsem_data *d)
{
        guard(rwsem_init)(&d->sem);
        d->counter = 0;
}

static void __used test_rwsem_reader(struct test_rwsem_data *d)
{
        down_read(&d->sem);
        (void)d->counter;
        up_read(&d->sem);

        if (down_read_trylock(&d->sem)) {
                (void)d->counter;
                up_read(&d->sem);
        }
}

static void __used test_rwsem_writer(struct test_rwsem_data *d)
{
        down_write(&d->sem);
        d->counter++;
        up_write(&d->sem);

        down_write(&d->sem);
        d->counter++;
        downgrade_write(&d->sem);
        (void)d->counter;
        up_read(&d->sem);

        if (down_write_trylock(&d->sem)) {
                d->counter++;
                up_write(&d->sem);
        }
}

static void __used test_rwsem_assert(struct test_rwsem_data *d)
{
        rwsem_assert_held_nolockdep(&d->sem);
        d->counter++;
}

static void __used test_rwsem_guard(struct test_rwsem_data *d)
{
        { guard(rwsem_read)(&d->sem); (void)d->counter; }
        { guard(rwsem_write)(&d->sem); d->counter++; }
}

static void __used test_rwsem_cond_guard(struct test_rwsem_data *d)
{
        scoped_cond_guard(rwsem_read_try, return, &d->sem) {
                (void)d->counter;
        }
        scoped_cond_guard(rwsem_write_try, return, &d->sem) {
                d->counter++;
        }
}

struct test_bit_spinlock_data {
        unsigned long bits;
        int counter __guarded_by(__bitlock(3, &bits));
};

static void __used test_bit_spin_lock(struct test_bit_spinlock_data *d)
{
        /*
         * Note, the analysis seems to have false negatives, because it won't
         * precisely recognize the bit of the fake __bitlock() token.
         */
        bit_spin_lock(3, &d->bits);
        d->counter++;
        bit_spin_unlock(3, &d->bits);

        bit_spin_lock(3, &d->bits);
        d->counter++;
        __bit_spin_unlock(3, &d->bits);

        if (bit_spin_trylock(3, &d->bits)) {
                d->counter++;
                bit_spin_unlock(3, &d->bits);
        }
}

/*
 * Test that we can mark a variable guarded by RCU, and we can dereference and
 * write to the pointer with RCU's primitives.
 */
struct test_rcu_data {
        long __rcu_guarded *data;
};

static void __used test_rcu_guarded_reader(struct test_rcu_data *d)
{
        rcu_read_lock();
        (void)rcu_dereference(d->data);
        rcu_read_unlock();

        rcu_read_lock_bh();
        (void)rcu_dereference(d->data);
        rcu_read_unlock_bh();

        rcu_read_lock_sched();
        (void)rcu_dereference(d->data);
        rcu_read_unlock_sched();
}

static void __used test_rcu_guard(struct test_rcu_data *d)
{
        guard(rcu)();
        (void)rcu_dereference(d->data);
}

static void __used test_rcu_guarded_updater(struct test_rcu_data *d)
{
        rcu_assign_pointer(d->data, NULL);
        RCU_INIT_POINTER(d->data, NULL);
        (void)unrcu_pointer(d->data);
}

static void wants_rcu_held(void)        __must_hold_shared(RCU)       { }
static void wants_rcu_held_bh(void)     __must_hold_shared(RCU_BH)    { }
static void wants_rcu_held_sched(void)  __must_hold_shared(RCU_SCHED) { }

static void __used test_rcu_lock_variants(void)
{
        rcu_read_lock();
        wants_rcu_held();
        rcu_read_unlock();

        rcu_read_lock_bh();
        wants_rcu_held_bh();
        rcu_read_unlock_bh();

        rcu_read_lock_sched();
        wants_rcu_held_sched();
        rcu_read_unlock_sched();
}

static void __used test_rcu_lock_reentrant(void)
{
        rcu_read_lock();
        rcu_read_lock();
        rcu_read_lock_bh();
        rcu_read_lock_bh();
        rcu_read_lock_sched();
        rcu_read_lock_sched();

        rcu_read_unlock_sched();
        rcu_read_unlock_sched();
        rcu_read_unlock_bh();
        rcu_read_unlock_bh();
        rcu_read_unlock();
        rcu_read_unlock();
}

static void __used test_rcu_assert_variants(void)
{
        lockdep_assert_in_rcu_read_lock();
        wants_rcu_held();

        lockdep_assert_in_rcu_read_lock_bh();
        wants_rcu_held_bh();

        lockdep_assert_in_rcu_read_lock_sched();
        wants_rcu_held_sched();
}

struct test_srcu_data {
        struct srcu_struct srcu;
        long __rcu_guarded *data;
};

static void __used test_srcu(struct test_srcu_data *d)
{
        init_srcu_struct(&d->srcu);

        int idx = srcu_read_lock(&d->srcu);
        long *data = srcu_dereference(d->data, &d->srcu);
        (void)data;
        srcu_read_unlock(&d->srcu, idx);

        rcu_assign_pointer(d->data, NULL);
}

static void __used test_srcu_guard(struct test_srcu_data *d)
{
        { guard(srcu)(&d->srcu); (void)srcu_dereference(d->data, &d->srcu); }
        { guard(srcu_fast)(&d->srcu); (void)srcu_dereference(d->data, &d->srcu); }
        { guard(srcu_fast_notrace)(&d->srcu); (void)srcu_dereference(d->data, &d->srcu); }
}

struct test_local_lock_data {
        local_lock_t lock;
        int counter __guarded_by(&lock);
};

static DEFINE_PER_CPU(struct test_local_lock_data, test_local_lock_data) = {
        .lock = INIT_LOCAL_LOCK(lock),
};

static void __used test_local_lock_init(struct test_local_lock_data *d)
{
        guard(local_lock_init)(&d->lock);
        d->counter = 0;
}

static void __used test_local_lock(void)
{
        unsigned long flags;

        local_lock(&test_local_lock_data.lock);
        this_cpu_add(test_local_lock_data.counter, 1);
        local_unlock(&test_local_lock_data.lock);

        local_lock_irq(&test_local_lock_data.lock);
        this_cpu_add(test_local_lock_data.counter, 1);
        local_unlock_irq(&test_local_lock_data.lock);

        local_lock_irqsave(&test_local_lock_data.lock, flags);
        this_cpu_add(test_local_lock_data.counter, 1);
        local_unlock_irqrestore(&test_local_lock_data.lock, flags);

        local_lock_nested_bh(&test_local_lock_data.lock);
        this_cpu_add(test_local_lock_data.counter, 1);
        local_unlock_nested_bh(&test_local_lock_data.lock);
}

static void __used test_local_lock_guard(void)
{
        { guard(local_lock)(&test_local_lock_data.lock); this_cpu_add(test_local_lock_data.counter, 1); }
        { guard(local_lock_irq)(&test_local_lock_data.lock); this_cpu_add(test_local_lock_data.counter, 1); }
        { guard(local_lock_irqsave)(&test_local_lock_data.lock); this_cpu_add(test_local_lock_data.counter, 1); }
        { guard(local_lock_nested_bh)(&test_local_lock_data.lock); this_cpu_add(test_local_lock_data.counter, 1); }
}

struct test_local_trylock_data {
        local_trylock_t lock;
        int counter __guarded_by(&lock);
};

static DEFINE_PER_CPU(struct test_local_trylock_data, test_local_trylock_data) = {
        .lock = INIT_LOCAL_TRYLOCK(lock),
};

static void __used test_local_trylock_init(struct test_local_trylock_data *d)
{
        guard(local_trylock_init)(&d->lock);
        d->counter = 0;
}

static void __used test_local_trylock(void)
{
        local_lock(&test_local_trylock_data.lock);
        this_cpu_add(test_local_trylock_data.counter, 1);
        local_unlock(&test_local_trylock_data.lock);

        if (local_trylock(&test_local_trylock_data.lock)) {
                this_cpu_add(test_local_trylock_data.counter, 1);
                local_unlock(&test_local_trylock_data.lock);
        }
}

static DEFINE_WD_CLASS(ww_class);

struct test_ww_mutex_data {
        struct ww_mutex mtx;
        int counter __guarded_by(&mtx);
};

static void __used test_ww_mutex_lock_noctx(struct test_ww_mutex_data *d)
{
        if (!ww_mutex_lock(&d->mtx, NULL)) {
                d->counter++;
                ww_mutex_unlock(&d->mtx);
        }

        if (!ww_mutex_lock_interruptible(&d->mtx, NULL)) {
                d->counter++;
                ww_mutex_unlock(&d->mtx);
        }

        if (ww_mutex_trylock(&d->mtx, NULL)) {
                d->counter++;
                ww_mutex_unlock(&d->mtx);
        }

        ww_mutex_lock_slow(&d->mtx, NULL);
        d->counter++;
        ww_mutex_unlock(&d->mtx);

        ww_mutex_destroy(&d->mtx);
}

static void __used test_ww_mutex_lock_ctx(struct test_ww_mutex_data *d)
{
        struct ww_acquire_ctx ctx;

        ww_acquire_init(&ctx, &ww_class);

        if (!ww_mutex_lock(&d->mtx, &ctx)) {
                d->counter++;
                ww_mutex_unlock(&d->mtx);
        }

        if (!ww_mutex_lock_interruptible(&d->mtx, &ctx)) {
                d->counter++;
                ww_mutex_unlock(&d->mtx);
        }

        if (ww_mutex_trylock(&d->mtx, &ctx)) {
                d->counter++;
                ww_mutex_unlock(&d->mtx);
        }

        ww_mutex_lock_slow(&d->mtx, &ctx);
        d->counter++;
        ww_mutex_unlock(&d->mtx);

        ww_acquire_done(&ctx);
        ww_acquire_fini(&ctx);

        ww_mutex_destroy(&d->mtx);
}