apps/sel4test-tests/src/tests/interrupt.c - 3p/sel4/sel4test - Git at Google

 /*
  * Copyright 2017, Data61, CSIRO (ABN 41 687 119 230)
  *
  * SPDX-License-Identifier: BSD-2-Clause
  */

 #include <autoconf.h>
 #include <sel4test-driver/gen_config.h>
 #include <sel4/sel4.h>
 #include <vka/object.h>

 #include "../helpers.h"

 #include <utils/util.h>

 static void interrupt_helper(env_t env, volatile int *state, int runs, seL4_CPtr endpoint)
 {
     while (*state < runs) {
         *state = *state + 1;
         ZF_LOGD("Tick");
         sel4test_ntfn_timer_wait(env);
     }
     ZF_LOGD("Boom");
     sel4test_ntfn_timer_wait(env);

 }

 /* test an interrupt handling thread that inherits the scheduling context of the notification
  * object */
 static int test_interrupt_notification_sc(env_t env)
 {
     helper_thread_t helper;
     seL4_CPtr endpoint = vka_alloc_endpoint_leaky(&env->vka);
     volatile seL4_Word state = 0;
     seL4_Word runs = 10;
     int error;

     /* set up helper */
     create_helper_thread(env, &helper);
     start_helper(env, &helper, (helper_fn_t) interrupt_helper, (seL4_Word) env, (seL4_Word) &state,
                  runs, endpoint);
     set_helper_priority(env, &helper, 10);
     error = seL4_TCB_SetPriority(env->tcb, env->tcb, 9);
     test_eq(error, seL4_NoError);

     /* helper should not have finished */
     test_leq(state, runs);

     /* take away scheduling context and give it to notification object */
     error = api_sc_unbind(helper.thread.sched_context.cptr);
     test_eq(error, seL4_NoError);

     error = api_sc_bind(helper.thread.sched_context.cptr,
                         env->timer_notification.cptr);
     test_eq(error, seL4_NoError);

     sel4test_periodic_start(env, 10 * NS_IN_MS);

     /* wait for the helper */
     wait_for_helper(&helper);
     test_eq(state, runs);

     sel4test_timer_reset(env);

     return sel4test_get_result();
 }
 DEFINE_TEST(INTERRUPT0002, "Test interrupts with scheduling context donation from notification object",
             test_interrupt_notification_sc, config_set(CONFIG_HAVE_TIMER) &&config_set(CONFIG_KERNEL_MCS));

 /* test an interrupt handling thread with a scheduling context doesn't inherit the notification objects scheduling context */
 static int test_interrupt_notification_and_tcb_sc(env_t env)
 {
     helper_thread_t helper_with_sc, helper_without_sc;
     seL4_CPtr endpoint = vka_alloc_endpoint_leaky(&env->vka);
     volatile seL4_Word state_with_sc = 0;
     volatile seL4_Word state_without_sc = 0;
     seL4_Word runs = 10;
     int error;

     /* set up helpers */
     create_helper_thread(env, &helper_without_sc);
     start_helper(env, &helper_without_sc, (helper_fn_t) interrupt_helper, (seL4_Word) env, (seL4_Word) &state_without_sc,
                  runs, endpoint);
     set_helper_priority(env, &helper_without_sc, 10);


     create_helper_thread(env, &helper_with_sc);
     start_helper(env, &helper_with_sc, (helper_fn_t) interrupt_helper, (seL4_Word) env, (seL4_Word) &state_with_sc,
                  runs, endpoint);
     set_helper_priority(env, &helper_with_sc, 10);

     /* helper_with_sc will run first */
     error = seL4_TCB_SetPriority(env->tcb, env->tcb, 9);
     test_eq(error, seL4_NoError);

     /* both helpers should run and wait for irq */
     test_leq(state_with_sc, (seL4_Word) runs);
     test_leq(state_without_sc, (seL4_Word) runs);

     /* take away scheduling context from helper_without_sc and give it to notification object */
     error = api_sc_unbind(helper_without_sc.thread.sched_context.cptr);
     test_eq(error, seL4_NoError);

     sel4test_periodic_start(env, 10 * NS_IN_MS);

     error = api_sc_bind(helper_without_sc.thread.sched_context.cptr,
                         env->timer_notification.cptr);
     test_eq(error, seL4_NoError);

     /* wait for the helper */
     wait_for_helper(&helper_with_sc);
     test_eq(state_with_sc, runs);

     wait_for_helper(&helper_without_sc);
     test_eq(state_without_sc, runs);

     sel4test_timer_reset(env);

     return sel4test_get_result();
 }
 DEFINE_TEST(INTERRUPT0003,
             "Test interrupts with scheduling context donation from notification object and without (two clients)",
             test_interrupt_notification_and_tcb_sc, config_set(CONFIG_HAVE_TIMER) &&config_set(CONFIG_KERNEL_MCS));

 /* test that if niether the thread or notification object have a scheduling context, nothing happens */
 static int test_interrupt_no_sc(env_t env)
 {
     helper_thread_t helper;
     seL4_CPtr endpoint = vka_alloc_endpoint_leaky(&env->vka);
     volatile seL4_Word state = 0;
     seL4_Word runs = 10;
     int error;

     /* set up helper */
     create_helper_thread(env, &helper);
     start_helper(env, &helper, (helper_fn_t) interrupt_helper, (seL4_Word) env, (seL4_Word) &state,
                  runs, endpoint);
     set_helper_priority(env, &helper, 10);
     error = seL4_TCB_SetPriority(env->tcb, env->tcb, 9);
     test_eq(error, seL4_NoError);

     /* helper should run and wait for irq */
     test_leq(state, (seL4_Word) runs);
     seL4_Word prev_state = state;

     /* take away scheduling context */
     error = api_sc_unbind(helper.thread.sched_context.cptr);
     test_eq(error, seL4_NoError);

     sel4test_periodic_start(env, 10 * NS_IN_MS);

     test_eq(state, (seL4_Word) prev_state);

     sel4test_timer_reset(env);

     return sel4test_get_result();
 }
 DEFINE_TEST(INTERRUPT0004, "Test interrupts with no scheduling context at all", test_interrupt_no_sc,
             config_set(CONFIG_HAVE_TIMER) &&config_set(CONFIG_KERNEL_MCS));

 /* test that a second interrupt handling thread on the same endpoint works */
 int test_interrupt_notification_sc_two_clients(env_t env)
 {
     helper_thread_t helper_first, helper_second;
     seL4_CPtr endpoint = vka_alloc_endpoint_leaky(&env->vka);
     volatile seL4_Word state_first = 0;
     volatile seL4_Word state_second = 0;
     seL4_Word runs = 10;
     int error;

     /* set up helpers */
     create_helper_thread(env, &helper_second);
     start_helper(env, &helper_second, (helper_fn_t) interrupt_helper, (seL4_Word) env, (seL4_Word) &state_first,
                  runs, endpoint);
     set_helper_priority(env, &helper_second, 10);

     create_helper_thread(env, &helper_first);
     start_helper(env, &helper_first, (helper_fn_t) interrupt_helper, (seL4_Word) env, (seL4_Word) &state_second,
                  runs, endpoint);
     set_helper_priority(env, &helper_first, 10);

     /* helper_with_sc will run first */
     error = seL4_TCB_SetPriority(env->tcb, env->tcb, 9);
     test_eq(error, seL4_NoError);

     /* both helpers should run and wait for irq */
     test_leq(state_first, (seL4_Word) runs);
     test_leq(state_second, (seL4_Word) runs);

     /* take away scheduling context from both, give one to a notification object */
     error = api_sc_unbind(helper_first.thread.sched_context.cptr);
     test_eq(error, seL4_NoError);

     error = api_sc_unbind(helper_second.thread.sched_context.cptr);
     test_eq(error, seL4_NoError);

     error = api_sc_bind(helper_first.thread.sched_context.cptr,
                         env->timer_notification.cptr);
     test_eq(error, seL4_NoError);

     sel4test_periodic_start(env, 10 * NS_IN_MS);

     /* wait for the helper */
     wait_for_helper(&helper_first);
     /* second will not exit as first stole the scheduling context when it exited */

     test_eq(state_first, runs);
     test_eq(state_second, runs);

     sel4test_timer_reset(env);

     return sel4test_get_result();
 }
 DEFINE_TEST(INTERRUPT0005, "Test the same scheduling context cannot be loaned to different threads",
             test_interrupt_notification_sc_two_clients, config_set(CONFIG_HAVE_TIMER) &&config_set(CONFIG_KERNEL_MCS));

 /* test deleting the scheduling context stops the notification from donating it */
 static int test_interrupt_delete_sc(env_t env)
 {
     helper_thread_t helper;
     seL4_CPtr endpoint = vka_alloc_endpoint_leaky(&env->vka);
     volatile seL4_Word state = 0;
     seL4_Word runs = 10;
     int error;

     /* set up helper */
     create_helper_thread(env, &helper);
     start_helper(env, &helper, (helper_fn_t) interrupt_helper, (seL4_Word) env, (seL4_Word) &state,
                  runs, endpoint);
     set_helper_priority(env, &helper, 10);
     error = seL4_TCB_SetPriority(env->tcb, env->tcb, 9);
     test_eq(error, seL4_NoError);

     /* helper should run and wait for irq */
     test_leq(state, (seL4_Word) runs);
     seL4_Word prev_state = state;

     /* take away scheduling context and give it to notification object */
     error = api_sc_unbind(helper.thread.sched_context.cptr);
     test_eq(error, seL4_NoError);

     error = api_sc_bind(helper.thread.sched_context.cptr,
                         env->timer_notification.cptr);
     test_eq(error, seL4_NoError);

     /* now delete it */
     vka_free_object(&env->vka, &helper.thread.sched_context);

     sel4test_periodic_start(env, 10 * NS_IN_MS);

     test_eq(state, prev_state);

     sel4test_timer_reset(env);
     return sel4test_get_result();
 }
 DEFINE_TEST(INTERRUPT0006, "Test interrupts after deleting scheduling context bound to notification",
             test_interrupt_delete_sc, config_set(CONFIG_HAVE_TIMER) &&config_set(CONFIG_KERNEL_MCS));
	/*
	* Copyright 2017, Data61, CSIRO (ABN 41 687 119 230)
	*
	* SPDX-License-Identifier: BSD-2-Clause
	*/

	#include <autoconf.h>
	#include <sel4test-driver/gen_config.h>
	#include <sel4/sel4.h>
	#include <vka/object.h>

	#include "../helpers.h"

	#include <utils/util.h>

	static void interrupt_helper(env_t env, volatile int *state, int runs, seL4_CPtr endpoint)
	{
	while (*state < runs) {
	state = state + 1;
	ZF_LOGD("Tick");
	sel4test_ntfn_timer_wait(env);
	}
	ZF_LOGD("Boom");
	sel4test_ntfn_timer_wait(env);

	}

	/* test an interrupt handling thread that inherits the scheduling context of the notification
	* object */
	static int test_interrupt_notification_sc(env_t env)
	{
	helper_thread_t helper;
	seL4_CPtr endpoint = vka_alloc_endpoint_leaky(&env->vka);
	volatile seL4_Word state = 0;
	seL4_Word runs = 10;
	int error;

	/* set up helper */
	create_helper_thread(env, &helper);
	start_helper(env, &helper, (helper_fn_t) interrupt_helper, (seL4_Word) env, (seL4_Word) &state,
	runs, endpoint);
	set_helper_priority(env, &helper, 10);
	error = seL4_TCB_SetPriority(env->tcb, env->tcb, 9);
	test_eq(error, seL4_NoError);

	/* helper should not have finished */
	test_leq(state, runs);

	/* take away scheduling context and give it to notification object */
	error = api_sc_unbind(helper.thread.sched_context.cptr);
	test_eq(error, seL4_NoError);

	error = api_sc_bind(helper.thread.sched_context.cptr,
	env->timer_notification.cptr);
	test_eq(error, seL4_NoError);

	sel4test_periodic_start(env, 10 * NS_IN_MS);

	/* wait for the helper */
	wait_for_helper(&helper);
	test_eq(state, runs);

	sel4test_timer_reset(env);

	return sel4test_get_result();
	}
	DEFINE_TEST(INTERRUPT0002, "Test interrupts with scheduling context donation from notification object",
	test_interrupt_notification_sc, config_set(CONFIG_HAVE_TIMER) &&config_set(CONFIG_KERNEL_MCS));

	/* test an interrupt handling thread with a scheduling context doesn't inherit the notification objects scheduling context */
	static int test_interrupt_notification_and_tcb_sc(env_t env)
	{
	helper_thread_t helper_with_sc, helper_without_sc;
	seL4_CPtr endpoint = vka_alloc_endpoint_leaky(&env->vka);
	volatile seL4_Word state_with_sc = 0;
	volatile seL4_Word state_without_sc = 0;
	seL4_Word runs = 10;
	int error;

	/* set up helpers */
	create_helper_thread(env, &helper_without_sc);
	start_helper(env, &helper_without_sc, (helper_fn_t) interrupt_helper, (seL4_Word) env, (seL4_Word) &state_without_sc,
	runs, endpoint);
	set_helper_priority(env, &helper_without_sc, 10);


	create_helper_thread(env, &helper_with_sc);
	start_helper(env, &helper_with_sc, (helper_fn_t) interrupt_helper, (seL4_Word) env, (seL4_Word) &state_with_sc,
	runs, endpoint);
	set_helper_priority(env, &helper_with_sc, 10);

	/* helper_with_sc will run first */
	error = seL4_TCB_SetPriority(env->tcb, env->tcb, 9);
	test_eq(error, seL4_NoError);

	/* both helpers should run and wait for irq */
	test_leq(state_with_sc, (seL4_Word) runs);
	test_leq(state_without_sc, (seL4_Word) runs);

	/* take away scheduling context from helper_without_sc and give it to notification object */
	error = api_sc_unbind(helper_without_sc.thread.sched_context.cptr);
	test_eq(error, seL4_NoError);

	sel4test_periodic_start(env, 10 * NS_IN_MS);

	error = api_sc_bind(helper_without_sc.thread.sched_context.cptr,
	env->timer_notification.cptr);
	test_eq(error, seL4_NoError);

	/* wait for the helper */
	wait_for_helper(&helper_with_sc);
	test_eq(state_with_sc, runs);

	wait_for_helper(&helper_without_sc);
	test_eq(state_without_sc, runs);

	sel4test_timer_reset(env);

	return sel4test_get_result();
	}
	DEFINE_TEST(INTERRUPT0003,
	"Test interrupts with scheduling context donation from notification object and without (two clients)",
	test_interrupt_notification_and_tcb_sc, config_set(CONFIG_HAVE_TIMER) &&config_set(CONFIG_KERNEL_MCS));

	/* test that if niether the thread or notification object have a scheduling context, nothing happens */
	static int test_interrupt_no_sc(env_t env)
	{
	helper_thread_t helper;
	seL4_CPtr endpoint = vka_alloc_endpoint_leaky(&env->vka);
	volatile seL4_Word state = 0;
	seL4_Word runs = 10;
	int error;

	/* set up helper */
	create_helper_thread(env, &helper);
	start_helper(env, &helper, (helper_fn_t) interrupt_helper, (seL4_Word) env, (seL4_Word) &state,
	runs, endpoint);
	set_helper_priority(env, &helper, 10);
	error = seL4_TCB_SetPriority(env->tcb, env->tcb, 9);
	test_eq(error, seL4_NoError);

	/* helper should run and wait for irq */
	test_leq(state, (seL4_Word) runs);
	seL4_Word prev_state = state;

	/* take away scheduling context */
	error = api_sc_unbind(helper.thread.sched_context.cptr);
	test_eq(error, seL4_NoError);

	sel4test_periodic_start(env, 10 * NS_IN_MS);

	test_eq(state, (seL4_Word) prev_state);

	sel4test_timer_reset(env);

	return sel4test_get_result();
	}
	DEFINE_TEST(INTERRUPT0004, "Test interrupts with no scheduling context at all", test_interrupt_no_sc,
	config_set(CONFIG_HAVE_TIMER) &&config_set(CONFIG_KERNEL_MCS));

	/* test that a second interrupt handling thread on the same endpoint works */
	int test_interrupt_notification_sc_two_clients(env_t env)
	{
	helper_thread_t helper_first, helper_second;
	seL4_CPtr endpoint = vka_alloc_endpoint_leaky(&env->vka);
	volatile seL4_Word state_first = 0;
	volatile seL4_Word state_second = 0;
	seL4_Word runs = 10;
	int error;

	/* set up helpers */
	create_helper_thread(env, &helper_second);
	start_helper(env, &helper_second, (helper_fn_t) interrupt_helper, (seL4_Word) env, (seL4_Word) &state_first,
	runs, endpoint);
	set_helper_priority(env, &helper_second, 10);

	create_helper_thread(env, &helper_first);
	start_helper(env, &helper_first, (helper_fn_t) interrupt_helper, (seL4_Word) env, (seL4_Word) &state_second,
	runs, endpoint);
	set_helper_priority(env, &helper_first, 10);

	/* helper_with_sc will run first */
	error = seL4_TCB_SetPriority(env->tcb, env->tcb, 9);
	test_eq(error, seL4_NoError);

	/* both helpers should run and wait for irq */
	test_leq(state_first, (seL4_Word) runs);
	test_leq(state_second, (seL4_Word) runs);

	/* take away scheduling context from both, give one to a notification object */
	error = api_sc_unbind(helper_first.thread.sched_context.cptr);
	test_eq(error, seL4_NoError);

	error = api_sc_unbind(helper_second.thread.sched_context.cptr);
	test_eq(error, seL4_NoError);

	error = api_sc_bind(helper_first.thread.sched_context.cptr,
	env->timer_notification.cptr);
	test_eq(error, seL4_NoError);

	sel4test_periodic_start(env, 10 * NS_IN_MS);

	/* wait for the helper */
	wait_for_helper(&helper_first);
	/* second will not exit as first stole the scheduling context when it exited */

	test_eq(state_first, runs);
	test_eq(state_second, runs);

	sel4test_timer_reset(env);

	return sel4test_get_result();
	}
	DEFINE_TEST(INTERRUPT0005, "Test the same scheduling context cannot be loaned to different threads",
	test_interrupt_notification_sc_two_clients, config_set(CONFIG_HAVE_TIMER) &&config_set(CONFIG_KERNEL_MCS));

	/* test deleting the scheduling context stops the notification from donating it */
	static int test_interrupt_delete_sc(env_t env)
	{
	helper_thread_t helper;
	seL4_CPtr endpoint = vka_alloc_endpoint_leaky(&env->vka);
	volatile seL4_Word state = 0;
	seL4_Word runs = 10;
	int error;

	/* set up helper */
	create_helper_thread(env, &helper);
	start_helper(env, &helper, (helper_fn_t) interrupt_helper, (seL4_Word) env, (seL4_Word) &state,
	runs, endpoint);
	set_helper_priority(env, &helper, 10);
	error = seL4_TCB_SetPriority(env->tcb, env->tcb, 9);
	test_eq(error, seL4_NoError);

	/* helper should run and wait for irq */
	test_leq(state, (seL4_Word) runs);
	seL4_Word prev_state = state;

	/* take away scheduling context and give it to notification object */
	error = api_sc_unbind(helper.thread.sched_context.cptr);
	test_eq(error, seL4_NoError);

	error = api_sc_bind(helper.thread.sched_context.cptr,
	env->timer_notification.cptr);
	test_eq(error, seL4_NoError);

	/* now delete it */
	vka_free_object(&env->vka, &helper.thread.sched_context);

	sel4test_periodic_start(env, 10 * NS_IN_MS);

	test_eq(state, prev_state);

	sel4test_timer_reset(env);
	return sel4test_get_result();
	}
	DEFINE_TEST(INTERRUPT0006, "Test interrupts after deleting scheduling context bound to notification",
	test_interrupt_delete_sc, config_set(CONFIG_HAVE_TIMER) &&config_set(CONFIG_KERNEL_MCS));