kernel/tests/preempt_disable_tests.cpp - zircon/ - Git at Google

 // Copyright 2018 The Fuchsia Authors
 //
 // Use of this source code is governed by a MIT-style
 // license that can be found in the LICENSE file or at
 // https://opensource.org/licenses/MIT

 #include <fbl/atomic.h>
 #include <kernel/event.h>
 #include <kernel/interrupt.h>
 #include <kernel/sched.h>
 #include <kernel/thread_lock.h>
 #include <kernel/timer.h>
 #include <platform.h>
 #include <lib/unittest/unittest.h>

 // Test that preempt_disable is set for timer callbacks and that, in this
 // context, preempt_pending will get set by some functions.
 static void timer_callback_func(timer_t* timer, zx_time_t now, void* arg) {
     event_t* event = (event_t*)arg;

     // Timer callbacks should be called in interrupt context with
     // preempt_disable set.
     ASSERT(arch_ints_disabled());
     ASSERT(arch_blocking_disallowed());
     thread_t* thread = get_current_thread();
     ASSERT(thread_preempt_disable_count() > 0);

     // Save and restore the value of preempt_pending so that we can test
     // other functions' behavior with preempt_pending==false.  It is
     // possible that preempt_pending is true now: it might have been set by
     // another timer callback.
     bool old_preempt_pending = thread->preempt_pending;

     // Test that sched_reschedule() sets the preempt_pending flag when
     // preempt_disable is set.
     thread->preempt_pending = false;
     {
         Guard<spin_lock_t, IrqSave> guard{ThreadLock::Get()};
         sched_reschedule();
     }
     ASSERT(thread->preempt_pending);

     // Test that thread_preempt_set_pending() sets the preempt_pending
     // flag.
     thread->preempt_pending = false;
     thread_preempt_set_pending();
     ASSERT(thread->preempt_pending);

     // Restore value.
     thread->preempt_pending = old_preempt_pending;

     event_signal(event, true);
 }

 // Schedule a timer callback and wait for it to complete.  Most of the
 // testing is done in the timer callback.
 static bool test_in_timer_callback() {
     BEGIN_TEST;

     event_t event;
     event_init(&event, false, 0);

     timer_t timer;
     timer_init(&timer);
     timer_set(&timer, Deadline::no_slack(0), timer_callback_func, &event);

     ASSERT_EQ(event_wait(&event), ZX_OK, "");
     event_destroy(&event);

     END_TEST;
 }

 // Test incrementing and decrementing the preempt_disable and
 // resched_disable counts.
 static bool test_inc_dec_disable_counts() {
     BEGIN_TEST;

     thread_t* thread = get_current_thread();

     // Test initial conditions.
     ASSERT_EQ(thread_preempt_disable_count(), 0u, "");
     ASSERT_EQ(thread_resched_disable_count(), 0u, "");
     // While preemption is allowed, a preemption should not be pending.
     ASSERT_EQ(thread->preempt_pending, false, "");

     // Test incrementing and decrementing of preempt_disable.
     thread_preempt_disable();
     EXPECT_EQ(thread_preempt_disable_count(), 1u, "");
     thread_preempt_reenable();
     EXPECT_EQ(thread_preempt_disable_count(), 0u, "");

     // Test incrementing and decrementing of resched_disable.
     thread_resched_disable();
     EXPECT_EQ(thread_resched_disable_count(), 1u, "");
     thread_resched_reenable();
     EXPECT_EQ(thread_resched_disable_count(), 0u, "");

     // Test nesting: multiple increments and decrements.
     thread_preempt_disable();
     thread_preempt_disable();
     EXPECT_EQ(thread_preempt_disable_count(), 2u, "");
     thread_preempt_reenable();
     thread_preempt_reenable();
     EXPECT_EQ(thread_preempt_disable_count(), 0u, "");

     // Test nesting: multiple increments and decrements.
     thread_resched_disable();
     thread_resched_disable();
     EXPECT_EQ(thread_resched_disable_count(), 2u, "");
     thread_resched_reenable();
     thread_resched_reenable();
     EXPECT_EQ(thread_resched_disable_count(), 0u, "");

     END_TEST;
 }

 static bool test_decrement_clears_preempt_pending() {
     BEGIN_TEST;

     thread_t* thread = get_current_thread();

     // Test that thread_preempt_reenable() clears preempt_pending.
     thread_preempt_disable();
     thread_reschedule();
     // It should not be possible for an interrupt handler to block or
     // otherwise cause a reschedule before our thread_preempt_reenable().
     EXPECT_EQ(thread->preempt_pending, true, "");
     thread_preempt_reenable();
     EXPECT_EQ(thread->preempt_pending, false, "");

     // Test that thread_resched_reenable() clears preempt_pending.
     thread_resched_disable();
     arch_disable_ints();
     thread_reschedule();
     // Read preempt_pending with interrupts disabled because otherwise an
     // interrupt handler could set it to false.
     EXPECT_EQ(thread->preempt_pending, true, "");
     arch_enable_ints();
     thread_resched_reenable();
     EXPECT_EQ(thread->preempt_pending, false, "");

     END_TEST;
 }

 static bool test_blocking_clears_preempt_pending() {
     BEGIN_TEST;

     thread_t* thread = get_current_thread();

     // It is OK to block while preemption is disabled.  In this case,
     // blocking should clear preempt_pending.
     thread_preempt_disable();
     thread_reschedule();
     EXPECT_EQ(thread->preempt_pending, true, "");
     arch_disable_ints();
     thread_sleep_relative(ZX_MSEC(10));
     // Read preempt_pending with interrupts disabled because otherwise an
     // interrupt handler could set it to true.
     EXPECT_EQ(thread->preempt_pending, false, "");
     arch_enable_ints();
     thread_preempt_reenable();

     // It is OK to block while rescheduling is disabled.  In this case,
     // blocking should clear preempt_pending.
     thread_resched_disable();
     thread_reschedule();
     thread_sleep_relative(ZX_MSEC(10));
     EXPECT_EQ(thread->preempt_pending, false, "");
     thread_resched_reenable();

     END_TEST;
 }

 // Test that preempt_pending is preserved across an interrupt handler when
 // resched_disable is set and when the interrupt handler does not cause a
 // preemption.  This tests the int_handler_start()/finish() routines rather
 // than the full interrupt handler.
 static bool test_interrupt_preserves_preempt_pending() {
     BEGIN_TEST;

     thread_t* thread = get_current_thread();

     thread_resched_disable();
     // Do this with interrupts disabled so that a real interrupt does not
     // clear preempt_pending.
     arch_disable_ints();
     thread_reschedule();

     // Simulate an interrupt handler invocation.
     int_handler_saved_state_t state;
     int_handler_start(&state);
     EXPECT_EQ(thread_preempt_disable_count(), 1u, "");
     bool do_preempt = int_handler_finish(&state);

     EXPECT_EQ(do_preempt, false, "");
     EXPECT_EQ(thread->preempt_pending, true, "");
     arch_enable_ints();
     thread_resched_reenable();
     EXPECT_EQ(thread->preempt_pending, false, "");

     END_TEST;
 }

 // Test that resched_disable does not prevent preemption by an interrupt
 // handler.
 static bool test_interrupt_clears_preempt_pending() {
     BEGIN_TEST;

     thread_t* thread = get_current_thread();

     thread_resched_disable();
     thread_reschedule();
     // Spin until we detect that we have been preempted.  preempt_pending
     // should eventually get set to false because the scheduler should
     // preempt this thread.
     while (thread->preempt_pending) {}
     thread_resched_reenable();

     END_TEST;
 }

 // Timer callback used for testing.
 static void timer_set_preempt_pending(timer_t* timer, zx_time_t now,
                                       void* arg) {
     auto* timer_ran = reinterpret_cast<fbl::atomic<bool>*>(arg);

     thread_preempt_set_pending();
     timer_ran->store(true);
 }

 static bool test_interrupt_with_preempt_disable() {
     BEGIN_TEST;

     thread_t* thread = get_current_thread();

     // Test that interrupt handlers honor preempt_disable.
     //
     // We test that by setting a timer callback that will set
     // preempt_pending from inside an interrupt handler.  preempt_pending
     // should remain set after the interrupt handler returns.
     //
     // This assumes that timer_set() will run the callback on the same CPU
     // that we invoked it from.  This also assumes that we don't
     // accidentally call any blocking operations that cause our thread to
     // be rescheduled to another CPU.
     thread_preempt_disable();
     fbl::atomic<bool> timer_ran(false);
     timer_t timer;
     timer_init(&timer);
     const Deadline deadline = Deadline::no_slack(current_time() + ZX_USEC(100));
     timer_set(&timer, deadline,
               timer_set_preempt_pending, reinterpret_cast<void*>(&timer_ran));
     // Spin until timer_ran is set by the interrupt handler.
     while (!timer_ran.load()) {}
     EXPECT_EQ(thread->preempt_pending, true, "");
     thread_preempt_reenable();

     END_TEST;
 }

 static bool test_interrupt_with_resched_disable() {
     BEGIN_TEST;

     thread_t* thread = get_current_thread();

     // Test that resched_disable does not defer preemptions by interrupt
     // handlers.
     //
     // This assumes that timer_set() will run the callback on the same CPU
     // that we invoked it from.
     thread_resched_disable();
     fbl::atomic<bool> timer_ran(false);
     timer_t timer;
     timer_init(&timer);
     const Deadline deadline = Deadline::no_slack(current_time() + ZX_USEC(100));
     timer_set(&timer, deadline,
               timer_set_preempt_pending, reinterpret_cast<void*>(&timer_ran));
     // Spin until timer_ran is set by the interrupt handler.
     while (!timer_ran.load()) {}
     // preempt_pending should be reset to false either on returning from
     // our timer interrupt, or by some other preemption.
     EXPECT_EQ(thread->preempt_pending, false, "");
     thread_resched_reenable();

     END_TEST;
 }

 UNITTEST_START_TESTCASE(preempt_disable_tests)
 UNITTEST("test_in_timer_callback", test_in_timer_callback)
 UNITTEST("test_inc_dec_disable_counts", test_inc_dec_disable_counts)
 UNITTEST("test_decrement_clears_preempt_pending",
          test_decrement_clears_preempt_pending)
 UNITTEST("test_blocking_clears_preempt_pending",
          test_blocking_clears_preempt_pending)
 UNITTEST("test_interrupt_preserves_preempt_pending",
          test_interrupt_preserves_preempt_pending)
 UNITTEST("test_interrupt_clears_preempt_pending",
          test_interrupt_clears_preempt_pending)
 UNITTEST("test_interrupt_with_preempt_disable",
          test_interrupt_with_preempt_disable)
 UNITTEST("test_interrupt_with_resched_disable",
          test_interrupt_with_resched_disable)
 UNITTEST_END_TESTCASE(preempt_disable_tests, "preempt_disable_tests",
                       "preempt_disable_tests");
	// Copyright 2018 The Fuchsia Authors
	//
	// Use of this source code is governed by a MIT-style
	// license that can be found in the LICENSE file or at
	// https://opensource.org/licenses/MIT

	#include <fbl/atomic.h>
	#include <kernel/event.h>
	#include <kernel/interrupt.h>
	#include <kernel/sched.h>
	#include <kernel/thread_lock.h>
	#include <kernel/timer.h>
	#include <platform.h>
	#include <lib/unittest/unittest.h>

	// Test that preempt_disable is set for timer callbacks and that, in this
	// context, preempt_pending will get set by some functions.
	static void timer_callback_func(timer_t* timer, zx_time_t now, void* arg) {
	event_t* event = (event_t*)arg;

	// Timer callbacks should be called in interrupt context with
	// preempt_disable set.
	ASSERT(arch_ints_disabled());
	ASSERT(arch_blocking_disallowed());
	thread_t* thread = get_current_thread();
	ASSERT(thread_preempt_disable_count() > 0);

	// Save and restore the value of preempt_pending so that we can test
	// other functions' behavior with preempt_pending==false. It is
	// possible that preempt_pending is true now: it might have been set by
	// another timer callback.
	bool old_preempt_pending = thread->preempt_pending;

	// Test that sched_reschedule() sets the preempt_pending flag when
	// preempt_disable is set.
	thread->preempt_pending = false;
	{
	Guard<spin_lock_t, IrqSave> guard{ThreadLock::Get()};
	sched_reschedule();
	}
	ASSERT(thread->preempt_pending);

	// Test that thread_preempt_set_pending() sets the preempt_pending
	// flag.
	thread->preempt_pending = false;
	thread_preempt_set_pending();
	ASSERT(thread->preempt_pending);

	// Restore value.
	thread->preempt_pending = old_preempt_pending;

	event_signal(event, true);
	}

	// Schedule a timer callback and wait for it to complete. Most of the
	// testing is done in the timer callback.
	static bool test_in_timer_callback() {
	BEGIN_TEST;

	event_t event;
	event_init(&event, false, 0);

	timer_t timer;
	timer_init(&timer);
	timer_set(&timer, Deadline::no_slack(0), timer_callback_func, &event);

	ASSERT_EQ(event_wait(&event), ZX_OK, "");
	event_destroy(&event);

	END_TEST;
	}

	// Test incrementing and decrementing the preempt_disable and
	// resched_disable counts.
	static bool test_inc_dec_disable_counts() {
	BEGIN_TEST;

	thread_t* thread = get_current_thread();

	// Test initial conditions.
	ASSERT_EQ(thread_preempt_disable_count(), 0u, "");
	ASSERT_EQ(thread_resched_disable_count(), 0u, "");
	// While preemption is allowed, a preemption should not be pending.
	ASSERT_EQ(thread->preempt_pending, false, "");

	// Test incrementing and decrementing of preempt_disable.
	thread_preempt_disable();
	EXPECT_EQ(thread_preempt_disable_count(), 1u, "");
	thread_preempt_reenable();
	EXPECT_EQ(thread_preempt_disable_count(), 0u, "");

	// Test incrementing and decrementing of resched_disable.
	thread_resched_disable();
	EXPECT_EQ(thread_resched_disable_count(), 1u, "");
	thread_resched_reenable();
	EXPECT_EQ(thread_resched_disable_count(), 0u, "");

	// Test nesting: multiple increments and decrements.
	thread_preempt_disable();
	thread_preempt_disable();
	EXPECT_EQ(thread_preempt_disable_count(), 2u, "");
	thread_preempt_reenable();
	thread_preempt_reenable();
	EXPECT_EQ(thread_preempt_disable_count(), 0u, "");

	// Test nesting: multiple increments and decrements.
	thread_resched_disable();
	thread_resched_disable();
	EXPECT_EQ(thread_resched_disable_count(), 2u, "");
	thread_resched_reenable();
	thread_resched_reenable();
	EXPECT_EQ(thread_resched_disable_count(), 0u, "");

	END_TEST;
	}

	static bool test_decrement_clears_preempt_pending() {
	BEGIN_TEST;

	thread_t* thread = get_current_thread();

	// Test that thread_preempt_reenable() clears preempt_pending.
	thread_preempt_disable();
	thread_reschedule();
	// It should not be possible for an interrupt handler to block or
	// otherwise cause a reschedule before our thread_preempt_reenable().
	EXPECT_EQ(thread->preempt_pending, true, "");
	thread_preempt_reenable();
	EXPECT_EQ(thread->preempt_pending, false, "");

	// Test that thread_resched_reenable() clears preempt_pending.
	thread_resched_disable();
	arch_disable_ints();
	thread_reschedule();
	// Read preempt_pending with interrupts disabled because otherwise an
	// interrupt handler could set it to false.
	EXPECT_EQ(thread->preempt_pending, true, "");
	arch_enable_ints();
	thread_resched_reenable();
	EXPECT_EQ(thread->preempt_pending, false, "");

	END_TEST;
	}

	static bool test_blocking_clears_preempt_pending() {
	BEGIN_TEST;

	thread_t* thread = get_current_thread();

	// It is OK to block while preemption is disabled. In this case,
	// blocking should clear preempt_pending.
	thread_preempt_disable();
	thread_reschedule();
	EXPECT_EQ(thread->preempt_pending, true, "");
	arch_disable_ints();
	thread_sleep_relative(ZX_MSEC(10));
	// Read preempt_pending with interrupts disabled because otherwise an
	// interrupt handler could set it to true.
	EXPECT_EQ(thread->preempt_pending, false, "");
	arch_enable_ints();
	thread_preempt_reenable();

	// It is OK to block while rescheduling is disabled. In this case,
	// blocking should clear preempt_pending.
	thread_resched_disable();
	thread_reschedule();
	thread_sleep_relative(ZX_MSEC(10));
	EXPECT_EQ(thread->preempt_pending, false, "");
	thread_resched_reenable();

	END_TEST;
	}

	// Test that preempt_pending is preserved across an interrupt handler when
	// resched_disable is set and when the interrupt handler does not cause a
	// preemption. This tests the int_handler_start()/finish() routines rather
	// than the full interrupt handler.
	static bool test_interrupt_preserves_preempt_pending() {
	BEGIN_TEST;

	thread_t* thread = get_current_thread();

	thread_resched_disable();
	// Do this with interrupts disabled so that a real interrupt does not
	// clear preempt_pending.
	arch_disable_ints();
	thread_reschedule();

	// Simulate an interrupt handler invocation.
	int_handler_saved_state_t state;
	int_handler_start(&state);
	EXPECT_EQ(thread_preempt_disable_count(), 1u, "");
	bool do_preempt = int_handler_finish(&state);

	EXPECT_EQ(do_preempt, false, "");
	EXPECT_EQ(thread->preempt_pending, true, "");
	arch_enable_ints();
	thread_resched_reenable();
	EXPECT_EQ(thread->preempt_pending, false, "");

	END_TEST;
	}

	// Test that resched_disable does not prevent preemption by an interrupt
	// handler.
	static bool test_interrupt_clears_preempt_pending() {
	BEGIN_TEST;

	thread_t* thread = get_current_thread();

	thread_resched_disable();
	thread_reschedule();
	// Spin until we detect that we have been preempted. preempt_pending
	// should eventually get set to false because the scheduler should
	// preempt this thread.
	while (thread->preempt_pending) {}
	thread_resched_reenable();

	END_TEST;
	}

	// Timer callback used for testing.
	static void timer_set_preempt_pending(timer_t* timer, zx_time_t now,
	void* arg) {
	auto* timer_ran = reinterpret_cast<fbl::atomic<bool>*>(arg);

	thread_preempt_set_pending();
	timer_ran->store(true);
	}

	static bool test_interrupt_with_preempt_disable() {
	BEGIN_TEST;

	thread_t* thread = get_current_thread();

	// Test that interrupt handlers honor preempt_disable.
	//
	// We test that by setting a timer callback that will set
	// preempt_pending from inside an interrupt handler. preempt_pending
	// should remain set after the interrupt handler returns.
	//
	// This assumes that timer_set() will run the callback on the same CPU
	// that we invoked it from. This also assumes that we don't
	// accidentally call any blocking operations that cause our thread to
	// be rescheduled to another CPU.
	thread_preempt_disable();
	fbl::atomic<bool> timer_ran(false);
	timer_t timer;
	timer_init(&timer);
	const Deadline deadline = Deadline::no_slack(current_time() + ZX_USEC(100));
	timer_set(&timer, deadline,
	timer_set_preempt_pending, reinterpret_cast<void*>(&timer_ran));
	// Spin until timer_ran is set by the interrupt handler.
	while (!timer_ran.load()) {}
	EXPECT_EQ(thread->preempt_pending, true, "");
	thread_preempt_reenable();

	END_TEST;
	}

	static bool test_interrupt_with_resched_disable() {
	BEGIN_TEST;

	thread_t* thread = get_current_thread();

	// Test that resched_disable does not defer preemptions by interrupt
	// handlers.
	//
	// This assumes that timer_set() will run the callback on the same CPU
	// that we invoked it from.
	thread_resched_disable();
	fbl::atomic<bool> timer_ran(false);
	timer_t timer;
	timer_init(&timer);
	const Deadline deadline = Deadline::no_slack(current_time() + ZX_USEC(100));
	timer_set(&timer, deadline,
	timer_set_preempt_pending, reinterpret_cast<void*>(&timer_ran));
	// Spin until timer_ran is set by the interrupt handler.
	while (!timer_ran.load()) {}
	// preempt_pending should be reset to false either on returning from
	// our timer interrupt, or by some other preemption.
	EXPECT_EQ(thread->preempt_pending, false, "");
	thread_resched_reenable();

	END_TEST;
	}

	UNITTEST_START_TESTCASE(preempt_disable_tests)
	UNITTEST("test_in_timer_callback", test_in_timer_callback)
	UNITTEST("test_inc_dec_disable_counts", test_inc_dec_disable_counts)
	UNITTEST("test_decrement_clears_preempt_pending",
	test_decrement_clears_preempt_pending)
	UNITTEST("test_blocking_clears_preempt_pending",
	test_blocking_clears_preempt_pending)
	UNITTEST("test_interrupt_preserves_preempt_pending",
	test_interrupt_preserves_preempt_pending)
	UNITTEST("test_interrupt_clears_preempt_pending",
	test_interrupt_clears_preempt_pending)
	UNITTEST("test_interrupt_with_preempt_disable",
	test_interrupt_with_preempt_disable)
	UNITTEST("test_interrupt_with_resched_disable",
	test_interrupt_with_resched_disable)
	UNITTEST_END_TESTCASE(preempt_disable_tests, "preempt_disable_tests",
	"preempt_disable_tests");