X-Git-Url: http://git.droids-corp.org/?a=blobdiff_plain;f=app%2Ftest%2Ftest_interrupts.c;h=d8c2d8124a4850da7c77cdddc4075e64c614c6fa;hb=742bde12f3bd008c2f06d744330436d8b1a56720;hp=d135242ebc17b0be323aef337be36e157d20c1e6;hpb=1c1d4d7a923d4804f1926fc5264f9ecdd8977b04;p=dpdk.git diff --git a/app/test/test_interrupts.c b/app/test/test_interrupts.c index d135242ebc..d8c2d8124a 100644 --- a/app/test/test_interrupts.c +++ b/app/test/test_interrupts.c @@ -1,61 +1,37 @@ -/*- - * BSD LICENSE - * - * Copyright(c) 2010-2013 Intel Corporation. All rights reserved. - * All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions - * are met: - * - * * Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * * Redistributions in binary form must reproduce the above copyright - * notice, this list of conditions and the following disclaimer in - * the documentation and/or other materials provided with the - * distribution. - * * Neither the name of Intel Corporation nor the names of its - * contributors may be used to endorse or promote products derived - * from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS - * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT - * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR - * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT - * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, - * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT - * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, - * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY - * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT - * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE - * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +/* SPDX-License-Identifier: BSD-3-Clause + * Copyright(c) 2010-2014 Intel Corporation */ #include #include #include -#include - #include #include #include #include "test.h" -#define TEST_INTERRUPT_CHECK_INTERVAL 1000 /* ms */ +#define TEST_INTERRUPT_CHECK_INTERVAL 100 /* ms */ -enum test_interrupt_handl_type { +/* predefined interrupt handle types */ +enum test_interrupt_handle_type { TEST_INTERRUPT_HANDLE_INVALID, TEST_INTERRUPT_HANDLE_VALID, + TEST_INTERRUPT_HANDLE_VALID_UIO, + TEST_INTERRUPT_HANDLE_VALID_ALARM, + TEST_INTERRUPT_HANDLE_VALID_DEV_EVENT, TEST_INTERRUPT_HANDLE_CASE1, TEST_INTERRUPT_HANDLE_MAX }; +/* flag of if callback is called */ static volatile int flag; static struct rte_intr_handle intr_handles[TEST_INTERRUPT_HANDLE_MAX]; +static enum test_interrupt_handle_type test_intr_type = + TEST_INTERRUPT_HANDLE_MAX; -#ifdef RTE_EXEC_ENV_LINUXAPP +#ifdef RTE_EXEC_ENV_LINUX union intr_pipefds{ struct { int pipefd[2]; @@ -68,6 +44,9 @@ union intr_pipefds{ static union intr_pipefds pfds; +/** + * Check if the interrupt handle is valid. + */ static inline int test_interrupt_handle_sanity_check(struct rte_intr_handle *intr_handle) { @@ -77,6 +56,9 @@ test_interrupt_handle_sanity_check(struct rte_intr_handle *intr_handle) return 0; } +/** + * Initialization for interrupt test. + */ static int test_interrupt_init(void) { @@ -84,17 +66,34 @@ test_interrupt_init(void) return -1; intr_handles[TEST_INTERRUPT_HANDLE_INVALID].fd = -1; - intr_handles[TEST_INTERRUPT_HANDLE_INVALID].type = RTE_INTR_HANDLE_UNKNOWN; + intr_handles[TEST_INTERRUPT_HANDLE_INVALID].type = + RTE_INTR_HANDLE_UNKNOWN; intr_handles[TEST_INTERRUPT_HANDLE_VALID].fd = pfds.readfd; - intr_handles[TEST_INTERRUPT_HANDLE_VALID].type = RTE_INTR_HANDLE_UNKNOWN; + intr_handles[TEST_INTERRUPT_HANDLE_VALID].type = + RTE_INTR_HANDLE_UNKNOWN; + + intr_handles[TEST_INTERRUPT_HANDLE_VALID_UIO].fd = pfds.readfd; + intr_handles[TEST_INTERRUPT_HANDLE_VALID_UIO].type = + RTE_INTR_HANDLE_UIO; - intr_handles[TEST_INTERRUPT_HANDLE_CASE1].fd = pfds.readfd; - intr_handles[TEST_INTERRUPT_HANDLE_CASE1].type = RTE_INTR_HANDLE_ALARM; + intr_handles[TEST_INTERRUPT_HANDLE_VALID_ALARM].fd = pfds.readfd; + intr_handles[TEST_INTERRUPT_HANDLE_VALID_ALARM].type = + RTE_INTR_HANDLE_ALARM; + + intr_handles[TEST_INTERRUPT_HANDLE_VALID_DEV_EVENT].fd = pfds.readfd; + intr_handles[TEST_INTERRUPT_HANDLE_VALID_DEV_EVENT].type = + RTE_INTR_HANDLE_DEV_EVENT; + + intr_handles[TEST_INTERRUPT_HANDLE_CASE1].fd = pfds.writefd; + intr_handles[TEST_INTERRUPT_HANDLE_CASE1].type = RTE_INTR_HANDLE_UIO; return 0; } +/** + * Deinitialization for interrupt test. + */ static int test_interrupt_deinit(void) { @@ -104,6 +103,9 @@ test_interrupt_deinit(void) return 0; } +/** + * Write the pipe to simulate an interrupt. + */ static int test_interrupt_trigger_interrupt(void) { @@ -113,6 +115,9 @@ test_interrupt_trigger_interrupt(void) return 0; } +/** + * Check if two interrupt handles are the same. + */ static int test_interrupt_handle_compare(struct rte_intr_handle *intr_handle_l, struct rte_intr_handle *intr_handle_r) @@ -128,7 +133,7 @@ test_interrupt_handle_compare(struct rte_intr_handle *intr_handle_l, } #else -/* to be implemented for baremetal later */ +/* to be implemented for bsd later */ static inline int test_interrupt_handle_sanity_check(struct rte_intr_handle *intr_handle) { @@ -164,11 +169,21 @@ test_interrupt_handle_compare(struct rte_intr_handle *intr_handle_l, return 0; } -#endif /* RTE_EXEC_ENV_LINUXAPP */ +#endif /* RTE_EXEC_ENV_LINUX */ +/** + * Callback for the test interrupt. + */ static void -test_interrupt_callback(struct rte_intr_handle *intr_handle, void *arg) +test_interrupt_callback(void *arg) { + struct rte_intr_handle *intr_handle = arg; + if (test_intr_type >= TEST_INTERRUPT_HANDLE_MAX) { + printf("invalid interrupt type\n"); + flag = -1; + return; + } + if (test_interrupt_handle_sanity_check(intr_handle) < 0) { printf("null or invalid intr_handle for %s\n", __func__); flag = -1; @@ -184,15 +199,17 @@ test_interrupt_callback(struct rte_intr_handle *intr_handle, void *arg) } if (test_interrupt_handle_compare(intr_handle, - &(intr_handles[TEST_INTERRUPT_HANDLE_VALID])) == 0) { + &(intr_handles[test_intr_type])) == 0) flag = 1; - } } +/** + * Callback for the test interrupt. + */ static void -test_interrupt_callback_1(struct rte_intr_handle *intr_handle, - __attribute__((unused)) void *arg) +test_interrupt_callback_1(void *arg) { + struct rte_intr_handle *intr_handle = arg; if (test_interrupt_handle_sanity_check(intr_handle) < 0) { printf("null or invalid intr_handle for %s\n", __func__); flag = -1; @@ -200,6 +217,9 @@ test_interrupt_callback_1(struct rte_intr_handle *intr_handle, } } +/** + * Tests for rte_intr_enable(). + */ static int test_interrupt_enable(void) { @@ -228,7 +248,29 @@ test_interrupt_enable(void) } /* check with specific valid intr_handle */ + test_intr_handle = intr_handles[TEST_INTERRUPT_HANDLE_VALID_ALARM]; + if (rte_intr_enable(&test_intr_handle) == 0) { + printf("unexpectedly enable a specific intr_handle " + "successfully\n"); + return -1; + } + + /* check with specific valid intr_handle */ + test_intr_handle = intr_handles[TEST_INTERRUPT_HANDLE_VALID_DEV_EVENT]; + if (rte_intr_enable(&test_intr_handle) == 0) { + printf("unexpectedly enable a specific intr_handle " + "successfully\n"); + return -1; + } + + /* check with valid handler and its type */ test_intr_handle = intr_handles[TEST_INTERRUPT_HANDLE_CASE1]; + if (rte_intr_enable(&test_intr_handle) < 0) { + printf("fail to enable interrupt on a simulated handler\n"); + return -1; + } + + test_intr_handle = intr_handles[TEST_INTERRUPT_HANDLE_VALID_UIO]; if (rte_intr_enable(&test_intr_handle) == 0) { printf("unexpectedly enable a specific intr_handle " "successfully\n"); @@ -238,6 +280,9 @@ test_interrupt_enable(void) return 0; } +/** + * Tests for rte_intr_disable(). + */ static int test_interrupt_disable(void) { @@ -267,70 +312,125 @@ test_interrupt_disable(void) } /* check with specific valid intr_handle */ - test_intr_handle = intr_handles[TEST_INTERRUPT_HANDLE_CASE1]; + test_intr_handle = intr_handles[TEST_INTERRUPT_HANDLE_VALID_ALARM]; if (rte_intr_disable(&test_intr_handle) == 0) { printf("unexpectedly disable a specific intr_handle " "successfully\n"); return -1; } - return 0; -} + /* check with specific valid intr_handle */ + test_intr_handle = intr_handles[TEST_INTERRUPT_HANDLE_VALID_DEV_EVENT]; + if (rte_intr_disable(&test_intr_handle) == 0) { + printf("unexpectedly disable a specific intr_handle " + "successfully\n"); + return -1; + } -int -test_interrupt(void) -{ - int count, ret; - struct rte_intr_handle test_intr_handle; + /* check with valid handler and its type */ + test_intr_handle = intr_handles[TEST_INTERRUPT_HANDLE_CASE1]; + if (rte_intr_disable(&test_intr_handle) < 0) { + printf("fail to disable interrupt on a simulated handler\n"); + return -1; + } - if (test_interrupt_init() < 0) { - printf("fail to do test init\n"); + test_intr_handle = intr_handles[TEST_INTERRUPT_HANDLE_VALID_UIO]; + if (rte_intr_disable(&test_intr_handle) == 0) { + printf("unexpectedly disable a specific intr_handle " + "successfully\n"); return -1; } - printf("check if callback registered can be called\n"); + return 0; +} - ret = -1; +/** + * Check the full path of a specified type of interrupt simulated. + */ +static int +test_interrupt_full_path_check(enum test_interrupt_handle_type intr_type) +{ + int count; + struct rte_intr_handle test_intr_handle; - /* check if callback registered can be called */ flag = 0; - test_intr_handle = intr_handles[TEST_INTERRUPT_HANDLE_VALID]; + test_intr_handle = intr_handles[intr_type]; + test_intr_type = intr_type; if (rte_intr_callback_register(&test_intr_handle, - test_interrupt_callback, NULL) < 0) { + test_interrupt_callback, &test_intr_handle) < 0) { printf("fail to register callback\n"); - goto out; - } - /* trigger an interrupt and then check if the callback can be called */ - if (test_interrupt_trigger_interrupt() < 0) { - printf("fail to trigger an interrupt\n"); - goto out; + return -1; } - /* check flag in 3 seconds */ + + if (test_interrupt_trigger_interrupt() < 0) + return -1; + + /* check flag */ for (count = 0; flag == 0 && count < 3; count++) rte_delay_ms(TEST_INTERRUPT_CHECK_INTERVAL); rte_delay_ms(TEST_INTERRUPT_CHECK_INTERVAL); + if (rte_intr_callback_unregister(&test_intr_handle, + test_interrupt_callback, &test_intr_handle) < 0) + return -1; - if ((ret = rte_intr_callback_unregister(&test_intr_handle, - test_interrupt_callback, NULL)) < 0) { - printf("rte_intr_callback_unregister() failed with error " - "code: %d\n", ret); + if (flag == 0) { + printf("callback has not been called\n"); + return -1; + } else if (flag < 0) { + printf("it has internal error in callback\n"); + return -1; + } + + return 0; +} + +/** + * Main function of testing interrupt. + */ +static int +test_interrupt(void) +{ + int ret = -1; + struct rte_intr_handle test_intr_handle; + + if (test_interrupt_init() < 0) { + printf("fail to initialize for testing interrupt\n"); + return -1; + } + + printf("Check unknown valid interrupt full path\n"); + if (test_interrupt_full_path_check(TEST_INTERRUPT_HANDLE_VALID) < 0) { + printf("failure occurred during checking unknown valid " + "interrupt full path\n"); goto out; } - ret = -1; - - if (flag == 0) { - printf("registered callback has not been called\n"); + printf("Check valid UIO interrupt full path\n"); + if (test_interrupt_full_path_check(TEST_INTERRUPT_HANDLE_VALID_UIO) + < 0) { + printf("failure occurred during checking valid UIO interrupt " + "full path\n"); goto out; - } else if (flag < 0) { - printf("registered callback failed\n"); - ret = flag; + } + + printf("Check valid device event interrupt full path\n"); + if (test_interrupt_full_path_check( + TEST_INTERRUPT_HANDLE_VALID_DEV_EVENT) < 0) { + printf("failure occurred during checking valid device event " + "interrupt full path\n"); goto out; } - printf("start register/unregister test\n"); + printf("Check valid alarm interrupt full path\n"); + if (test_interrupt_full_path_check( + TEST_INTERRUPT_HANDLE_VALID_ALARM) < 0) { + printf("failure occurred during checking valid alarm " + "interrupt full path\n"); + goto out; + } + printf("start register/unregister test\n"); /* check if it will fail to register cb with intr_handle = NULL */ if (rte_intr_callback_register(NULL, test_interrupt_callback, NULL) == 0) { @@ -342,7 +442,7 @@ test_interrupt(void) /* check if it will fail to register cb with invalid intr_handle */ test_intr_handle = intr_handles[TEST_INTERRUPT_HANDLE_INVALID]; if (rte_intr_callback_register(&test_intr_handle, - test_interrupt_callback, NULL) == 0) { + test_interrupt_callback, &test_intr_handle) == 0) { printf("unexpectedly register successfully with invalid " "intr_handle\n"); goto out; @@ -350,7 +450,7 @@ test_interrupt(void) /* check if it will fail to register without callback */ test_intr_handle = intr_handles[TEST_INTERRUPT_HANDLE_VALID]; - if (rte_intr_callback_register(&test_intr_handle, NULL, NULL) == 0) { + if (rte_intr_callback_register(&test_intr_handle, NULL, &test_intr_handle) == 0) { printf("unexpectedly register successfully with " "null callback\n"); goto out; @@ -367,7 +467,7 @@ test_interrupt(void) /* check if it will fail to unregister cb with invalid intr_handle */ test_intr_handle = intr_handles[TEST_INTERRUPT_HANDLE_INVALID]; if (rte_intr_callback_unregister(&test_intr_handle, - test_interrupt_callback, NULL) > 0) { + test_interrupt_callback, &test_intr_handle) > 0) { printf("unexpectedly unregister successfully with " "invalid intr_handle\n"); goto out; @@ -376,23 +476,24 @@ test_interrupt(void) /* check if it is ok to register the same intr_handle twice */ test_intr_handle = intr_handles[TEST_INTERRUPT_HANDLE_VALID]; if (rte_intr_callback_register(&test_intr_handle, - test_interrupt_callback, NULL) < 0) { + test_interrupt_callback, &test_intr_handle) < 0) { printf("it fails to register test_interrupt_callback\n"); goto out; } if (rte_intr_callback_register(&test_intr_handle, - test_interrupt_callback_1, NULL) < 0) { + test_interrupt_callback_1, &test_intr_handle) < 0) { printf("it fails to register test_interrupt_callback_1\n"); goto out; } /* check if it will fail to unregister with invalid parameter */ if (rte_intr_callback_unregister(&test_intr_handle, test_interrupt_callback, (void *)0xff) != 0) { - printf("unexpectedly unregisters successfully with invalid arg\n"); + printf("unexpectedly unregisters successfully with " + "invalid arg\n"); goto out; } if (rte_intr_callback_unregister(&test_intr_handle, - test_interrupt_callback, NULL) <= 0) { + test_interrupt_callback, &test_intr_handle) <= 0) { printf("it fails to unregister test_interrupt_callback\n"); goto out; } @@ -405,19 +506,23 @@ test_interrupt(void) rte_delay_ms(TEST_INTERRUPT_CHECK_INTERVAL); printf("start interrupt enable/disable test\n"); - /* check interrupt enable/disable functions */ - if (test_interrupt_enable() < 0) + if (test_interrupt_enable() < 0) { + printf("fail to check interrupt enabling\n"); goto out; + } rte_delay_ms(TEST_INTERRUPT_CHECK_INTERVAL); - if (test_interrupt_disable() < 0) + if (test_interrupt_disable() < 0) { + printf("fail to check interrupt disabling\n"); goto out; + } rte_delay_ms(TEST_INTERRUPT_CHECK_INTERVAL); ret = 0; out: + printf("Clearing for interrupt tests\n"); /* clear registered callbacks */ test_intr_handle = intr_handles[TEST_INTERRUPT_HANDLE_VALID]; rte_intr_callback_unregister(&test_intr_handle, @@ -425,6 +530,24 @@ out: rte_intr_callback_unregister(&test_intr_handle, test_interrupt_callback_1, (void *)-1); + test_intr_handle = intr_handles[TEST_INTERRUPT_HANDLE_VALID_UIO]; + rte_intr_callback_unregister(&test_intr_handle, + test_interrupt_callback, (void *)-1); + rte_intr_callback_unregister(&test_intr_handle, + test_interrupt_callback_1, (void *)-1); + + test_intr_handle = intr_handles[TEST_INTERRUPT_HANDLE_VALID_ALARM]; + rte_intr_callback_unregister(&test_intr_handle, + test_interrupt_callback, (void *)-1); + rte_intr_callback_unregister(&test_intr_handle, + test_interrupt_callback_1, (void *)-1); + + test_intr_handle = intr_handles[TEST_INTERRUPT_HANDLE_VALID_DEV_EVENT]; + rte_intr_callback_unregister(&test_intr_handle, + test_interrupt_callback, (void *)-1); + rte_intr_callback_unregister(&test_intr_handle, + test_interrupt_callback_1, (void *)-1); + rte_delay_ms(2 * TEST_INTERRUPT_CHECK_INTERVAL); /* deinit */ test_interrupt_deinit(); @@ -432,3 +555,4 @@ out: return ret; } +REGISTER_TEST_COMMAND(interrupt_autotest, test_interrupt);