mirror of
https://github.com/torvalds/linux.git
synced 2026-11-20 13:03:48 +00:00
Add a test case that races errseq_check_and_advance() on one CPU against errseq_set() of a different error on another CPU, then records the first error again and lets a second cursor consume it. The second -EIO is recorded after the first cursor's check returned, so that cursor's next check must report an error, whichever way the race with -ENOSPC went. Without the previous commit 1-6% of 2 million rounds lose the error on UML with 4 CPUs (seccomp=on ncpus=4); with it none do. The case is skipped on a single CPU and stops after 5 seconds. Signed-off-by: Shashank Mohan Jain <[email protected]> Link: https://patch.msgid.link/[email protected] Reviewed-by: Jan Kara <[email protected]> Reviewed-by: Jeff Layton <[email protected]> Signed-off-by: Christian Brauner (Amutable) <[email protected]>
338 lines
9.9 KiB
C
338 lines
9.9 KiB
C
// SPDX-License-Identifier: GPL-2.0
|
|
/*
|
|
* KUnit tests for the errseq_t error-tracking infrastructure.
|
|
*
|
|
* Most cases exercise the documented single-threaded semantics of the
|
|
* errseq API (see Documentation/core-api/errseq.rst and lib/errseq.c): error
|
|
* recording and overwriting, the "seen" handoff between errseq_sample()
|
|
* and errseq_check_and_advance(), and the re-reporting of an error that
|
|
* is recorded again after it has been seen.
|
|
*
|
|
* The WARN path for invalid error values is not tested. The last case
|
|
* races errseq_set() against errseq_check_and_advance() on another CPU.
|
|
*/
|
|
#include <kunit/test.h>
|
|
|
|
#include <linux/atomic.h>
|
|
#include <linux/cpumask.h>
|
|
#include <linux/err.h>
|
|
#include <linux/errno.h>
|
|
#include <linux/errseq.h>
|
|
#include <linux/jiffies.h>
|
|
#include <linux/kthread.h>
|
|
#include <linux/random.h>
|
|
#include <linux/sched.h>
|
|
|
|
/*
|
|
* A zeroed errseq_t is the "no error has ever occurred" epoch: it
|
|
* samples as zero and no check against it reports anything.
|
|
*/
|
|
static void errseq_test_zero_epoch_reports_no_error(struct kunit *test)
|
|
{
|
|
errseq_t eseq = 0;
|
|
errseq_t since = 0;
|
|
|
|
KUNIT_EXPECT_EQ(test, errseq_sample(&eseq), 0);
|
|
KUNIT_EXPECT_EQ(test, errseq_check(&eseq, 0), 0);
|
|
KUNIT_EXPECT_EQ(test, errseq_check_and_advance(&eseq, &since), 0);
|
|
KUNIT_EXPECT_EQ(test, since, 0);
|
|
}
|
|
|
|
static void errseq_test_set_records_error(struct kunit *test)
|
|
{
|
|
errseq_t eseq = 0;
|
|
|
|
/* errseq_set() returns the previous value; the epoch is zero. */
|
|
KUNIT_EXPECT_EQ(test, errseq_set(&eseq, -EIO), 0);
|
|
KUNIT_EXPECT_EQ(test, errseq_check(&eseq, 0), -EIO);
|
|
}
|
|
|
|
/* Any error set always overwrites an existing error. */
|
|
static void errseq_test_set_overwrites_error(struct kunit *test)
|
|
{
|
|
errseq_t eseq = 0;
|
|
|
|
errseq_set(&eseq, -EIO);
|
|
errseq_set(&eseq, -ENOSPC);
|
|
KUNIT_EXPECT_EQ(test, errseq_check(&eseq, 0), -ENOSPC);
|
|
}
|
|
|
|
/* Both ends of the valid error range are recorded exactly. */
|
|
static void errseq_test_errno_range_extremes(struct kunit *test)
|
|
{
|
|
errseq_t lo = 0;
|
|
errseq_t hi = 0;
|
|
|
|
errseq_set(&lo, -1);
|
|
KUNIT_EXPECT_EQ(test, errseq_check(&lo, 0), -1);
|
|
|
|
errseq_set(&hi, -MAX_ERRNO);
|
|
KUNIT_EXPECT_EQ(test, errseq_check(&hi, 0), -MAX_ERRNO);
|
|
}
|
|
|
|
/*
|
|
* An error nobody has seen yet samples as zero, so that a check against
|
|
* the sample still reports it (see commit b4678df184b3 ("errseq: Always
|
|
* report a writeback error once")).
|
|
*/
|
|
static void errseq_test_sample_of_unseen_error_is_zero(struct kunit *test)
|
|
{
|
|
errseq_t eseq = 0;
|
|
|
|
errseq_set(&eseq, -EIO);
|
|
KUNIT_EXPECT_EQ(test, errseq_sample(&eseq), 0);
|
|
}
|
|
|
|
static void errseq_test_new_sampler_sees_unseen_error(struct kunit *test)
|
|
{
|
|
errseq_t eseq = 0;
|
|
errseq_t since;
|
|
|
|
errseq_set(&eseq, -EIO);
|
|
since = errseq_sample(&eseq);
|
|
KUNIT_EXPECT_EQ(test, errseq_check(&eseq, since), -EIO);
|
|
}
|
|
|
|
/* A given error is reported exactly once per advancing cursor. */
|
|
static void errseq_test_check_and_advance_reports_once(struct kunit *test)
|
|
{
|
|
errseq_t eseq = 0;
|
|
errseq_t since = errseq_sample(&eseq);
|
|
|
|
errseq_set(&eseq, -EIO);
|
|
KUNIT_EXPECT_EQ(test, errseq_check_and_advance(&eseq, &since), -EIO);
|
|
KUNIT_EXPECT_EQ(test, errseq_check_and_advance(&eseq, &since), 0);
|
|
}
|
|
|
|
/*
|
|
* Once an error has been seen, a fresh sample is non-zero and checking
|
|
* against it reports nothing: handled errors do not reach new samplers.
|
|
*/
|
|
static void errseq_test_sample_after_seen_is_current(struct kunit *test)
|
|
{
|
|
errseq_t eseq = 0;
|
|
errseq_t since = 0;
|
|
errseq_t sample;
|
|
|
|
errseq_set(&eseq, -EIO);
|
|
KUNIT_EXPECT_EQ(test, errseq_check_and_advance(&eseq, &since), -EIO);
|
|
|
|
sample = errseq_sample(&eseq);
|
|
KUNIT_EXPECT_NE(test, sample, 0);
|
|
KUNIT_EXPECT_EQ(test, errseq_check(&eseq, sample), 0);
|
|
}
|
|
|
|
static void errseq_test_new_error_after_advance(struct kunit *test)
|
|
{
|
|
errseq_t eseq = 0;
|
|
errseq_t since = 0;
|
|
|
|
errseq_set(&eseq, -EIO);
|
|
KUNIT_EXPECT_EQ(test, errseq_check_and_advance(&eseq, &since), -EIO);
|
|
|
|
errseq_set(&eseq, -ENOSPC);
|
|
KUNIT_EXPECT_EQ(test, errseq_check_and_advance(&eseq, &since), -ENOSPC);
|
|
KUNIT_EXPECT_EQ(test, errseq_check_and_advance(&eseq, &since), 0);
|
|
}
|
|
|
|
/*
|
|
* Recording the same error again after it has been seen must bump the
|
|
* sequence, so cursors that consumed the first occurrence see the
|
|
* second one too.
|
|
*/
|
|
static void errseq_test_same_error_reported_again_after_seen(struct kunit *test)
|
|
{
|
|
errseq_t eseq = 0;
|
|
errseq_t since = 0;
|
|
errseq_t seen_cursor;
|
|
|
|
errseq_set(&eseq, -EIO);
|
|
KUNIT_EXPECT_EQ(test, errseq_check_and_advance(&eseq, &since), -EIO);
|
|
|
|
seen_cursor = since;
|
|
errseq_set(&eseq, -EIO);
|
|
KUNIT_EXPECT_EQ(test, errseq_check(&eseq, since), -EIO);
|
|
KUNIT_EXPECT_EQ(test, errseq_check_and_advance(&eseq, &since), -EIO);
|
|
/* The repeat must advance the sequence, not just re-toggle "seen". */
|
|
KUNIT_EXPECT_NE(test, since, seen_cursor);
|
|
}
|
|
|
|
/*
|
|
* A cursor that consumed an error must still observe a repeat of that
|
|
* error even when another cursor has already marked the repeat seen:
|
|
* recording over a seen value must advance the sequence.
|
|
*/
|
|
static void errseq_test_repeat_error_visible_to_all_cursors(struct kunit *test)
|
|
{
|
|
errseq_t eseq = 0;
|
|
errseq_t cursor_a = 0;
|
|
errseq_t cursor_b = 0;
|
|
|
|
errseq_set(&eseq, -EIO);
|
|
KUNIT_EXPECT_EQ(test, errseq_check_and_advance(&eseq, &cursor_a), -EIO);
|
|
|
|
errseq_set(&eseq, -EIO);
|
|
KUNIT_EXPECT_EQ(test, errseq_check_and_advance(&eseq, &cursor_b), -EIO);
|
|
|
|
KUNIT_EXPECT_EQ(test, errseq_check(&eseq, cursor_a), -EIO);
|
|
KUNIT_EXPECT_EQ(test, errseq_check_and_advance(&eseq, &cursor_a), -EIO);
|
|
KUNIT_EXPECT_EQ(test, errseq_check_and_advance(&eseq, &cursor_a), 0);
|
|
}
|
|
|
|
/* An advance with no new error reports nothing and leaves the cursor put. */
|
|
static void errseq_test_advance_stable_when_unchanged(struct kunit *test)
|
|
{
|
|
errseq_t eseq = 0;
|
|
errseq_t since = 0;
|
|
errseq_t cursor;
|
|
|
|
errseq_set(&eseq, -EIO);
|
|
KUNIT_EXPECT_EQ(test, errseq_check_and_advance(&eseq, &since), -EIO);
|
|
|
|
cursor = since;
|
|
KUNIT_EXPECT_EQ(test, errseq_check_and_advance(&eseq, &since), 0);
|
|
KUNIT_EXPECT_EQ(test, since, cursor);
|
|
}
|
|
|
|
/*
|
|
* Cursors are independent: one subscriber consuming an error does not
|
|
* consume it for another, and each subscriber sees each error once.
|
|
*/
|
|
static void errseq_test_two_subscribers_independent(struct kunit *test)
|
|
{
|
|
errseq_t eseq = 0;
|
|
errseq_t cursor_a = errseq_sample(&eseq);
|
|
errseq_t cursor_b = errseq_sample(&eseq);
|
|
|
|
errseq_set(&eseq, -EIO);
|
|
|
|
KUNIT_EXPECT_EQ(test, errseq_check_and_advance(&eseq, &cursor_a), -EIO);
|
|
KUNIT_EXPECT_EQ(test, errseq_check(&eseq, cursor_b), -EIO);
|
|
KUNIT_EXPECT_EQ(test, errseq_check_and_advance(&eseq, &cursor_b), -EIO);
|
|
|
|
KUNIT_EXPECT_EQ(test, errseq_check_and_advance(&eseq, &cursor_a), 0);
|
|
KUNIT_EXPECT_EQ(test, errseq_check_and_advance(&eseq, &cursor_b), 0);
|
|
}
|
|
|
|
/*
|
|
* errseq_check_and_advance() racing with errseq_set() on another CPU.
|
|
*
|
|
* Each round, cursor @f checks an unseen -EIO while another CPU records
|
|
* -ENOSPC. Afterwards -EIO is recorded again and cursor @g checks. The
|
|
* second -EIO is recorded after @f's check returned, so @f's next check
|
|
* must report an error, whichever way the race with -ENOSPC went.
|
|
*/
|
|
struct errseq_race {
|
|
errseq_t eseq;
|
|
atomic_t go; /* round the writer should run */
|
|
atomic_t done; /* last round the writer completed */
|
|
unsigned int wdelay;
|
|
};
|
|
|
|
static void errseq_race_spin(unsigned int n)
|
|
{
|
|
while (n--)
|
|
cpu_relax();
|
|
}
|
|
|
|
static int errseq_race_writer(void *data)
|
|
{
|
|
struct errseq_race *r = data;
|
|
int seen = 0;
|
|
|
|
while (!kthread_should_stop()) {
|
|
int round = atomic_read_acquire(&r->go);
|
|
|
|
if (round == seen) {
|
|
cond_resched();
|
|
continue;
|
|
}
|
|
seen = round;
|
|
errseq_race_spin(READ_ONCE(r->wdelay));
|
|
errseq_set(&r->eseq, -ENOSPC);
|
|
atomic_set_release(&r->done, round);
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
#define ERRSEQ_RACE_ROUNDS 2000000
|
|
#define ERRSEQ_RACE_SECONDS 5
|
|
|
|
static void errseq_test_check_and_advance_race(struct kunit *test)
|
|
{
|
|
struct errseq_race *r;
|
|
struct task_struct *writer;
|
|
unsigned long deadline;
|
|
int round, unreported = 0, missed = 0;
|
|
|
|
if (num_online_cpus() < 2)
|
|
kunit_skip(test, "needs at least two CPUs");
|
|
|
|
r = kunit_kzalloc(test, sizeof(*r), GFP_KERNEL);
|
|
KUNIT_ASSERT_NOT_NULL(test, r);
|
|
|
|
writer = kthread_run(errseq_race_writer, r, "errseq_race");
|
|
KUNIT_ASSERT_FALSE(test, IS_ERR(writer));
|
|
|
|
deadline = jiffies + ERRSEQ_RACE_SECONDS * HZ;
|
|
for (round = 1; round <= ERRSEQ_RACE_ROUNDS; round++) {
|
|
errseq_t f = 0, g = 0;
|
|
|
|
WRITE_ONCE(r->eseq, 0);
|
|
errseq_set(&r->eseq, -EIO);
|
|
WRITE_ONCE(r->wdelay, get_random_u32_below(64));
|
|
atomic_set_release(&r->go, round);
|
|
|
|
errseq_race_spin(get_random_u32_below(64));
|
|
if (!errseq_check_and_advance(&r->eseq, &f))
|
|
unreported++;
|
|
|
|
while (atomic_read_acquire(&r->done) != round)
|
|
cond_resched();
|
|
|
|
/* Recorded after f's check returned: f must hear about it. */
|
|
errseq_set(&r->eseq, -EIO);
|
|
errseq_check_and_advance(&r->eseq, &g);
|
|
if (!errseq_check_and_advance(&r->eseq, &f))
|
|
missed++;
|
|
|
|
if (time_after(jiffies, deadline))
|
|
break;
|
|
if (!(round & 1023))
|
|
cond_resched();
|
|
}
|
|
kthread_stop(writer);
|
|
|
|
kunit_info(test, "%d rounds, %d missed errors\n", round - 1, missed);
|
|
KUNIT_EXPECT_EQ(test, unreported, 0);
|
|
KUNIT_EXPECT_EQ(test, missed, 0);
|
|
}
|
|
|
|
static struct kunit_case errseq_test_cases[] = {
|
|
KUNIT_CASE(errseq_test_zero_epoch_reports_no_error),
|
|
KUNIT_CASE(errseq_test_set_records_error),
|
|
KUNIT_CASE(errseq_test_set_overwrites_error),
|
|
KUNIT_CASE(errseq_test_errno_range_extremes),
|
|
KUNIT_CASE(errseq_test_sample_of_unseen_error_is_zero),
|
|
KUNIT_CASE(errseq_test_new_sampler_sees_unseen_error),
|
|
KUNIT_CASE(errseq_test_check_and_advance_reports_once),
|
|
KUNIT_CASE(errseq_test_sample_after_seen_is_current),
|
|
KUNIT_CASE(errseq_test_new_error_after_advance),
|
|
KUNIT_CASE(errseq_test_same_error_reported_again_after_seen),
|
|
KUNIT_CASE(errseq_test_repeat_error_visible_to_all_cursors),
|
|
KUNIT_CASE(errseq_test_advance_stable_when_unchanged),
|
|
KUNIT_CASE(errseq_test_two_subscribers_independent),
|
|
KUNIT_CASE_SLOW(errseq_test_check_and_advance_race),
|
|
{}
|
|
};
|
|
|
|
static struct kunit_suite errseq_test_suite = {
|
|
.name = "errseq",
|
|
.test_cases = errseq_test_cases,
|
|
};
|
|
|
|
kunit_test_suite(errseq_test_suite);
|
|
|
|
MODULE_DESCRIPTION("KUnit tests for the errseq infrastructure");
|
|
MODULE_LICENSE("GPL");
|