mirror of
https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git
synced 2024-08-26 02:39:48 +00:00
![Arnd Bergmann](/assets/img/avatar_default.png)
clang does not support nested functions inside of an array definition: lib/test_static_keys.c:105:16: error: function definition is not allowed here .test_key = test_key_func(&old_true_key, static_key_true), lib/test_static_keys.c:50:20: note: expanded from macro 'test_key_func' ({bool func(void) { return branch(key); } func; }) That code appears to be a little too clever, so this simplifies it a bit by defining functions outside of the array. Signed-off-by: Arnd Bergmann <arnd@arndb.de> Acked-by: Jason Baron <jbaron@akamai.com> Cc: Linus Torvalds <torvalds@linux-foundation.org> Cc: Peter Zijlstra <peterz@infradead.org> Cc: Thomas Gleixner <tglx@linutronix.de> Cc: linux-arm-kernel@lists.infradead.org Link: http://lkml.kernel.org/r/1454942223-2781480-1-git-send-email-arnd@arndb.de Signed-off-by: Ingo Molnar <mingo@kernel.org>
247 lines
6 KiB
C
247 lines
6 KiB
C
/*
|
|
* Kernel module for testing static keys.
|
|
*
|
|
* Copyright 2015 Akamai Technologies Inc. All Rights Reserved
|
|
*
|
|
* Authors:
|
|
* Jason Baron <jbaron@akamai.com>
|
|
*
|
|
* This software is licensed under the terms of the GNU General Public
|
|
* License version 2, as published by the Free Software Foundation, and
|
|
* may be copied, distributed, and modified under those terms.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*/
|
|
|
|
#include <linux/module.h>
|
|
#include <linux/jump_label.h>
|
|
|
|
/* old keys */
|
|
struct static_key old_true_key = STATIC_KEY_INIT_TRUE;
|
|
struct static_key old_false_key = STATIC_KEY_INIT_FALSE;
|
|
|
|
/* new api */
|
|
DEFINE_STATIC_KEY_TRUE(true_key);
|
|
DEFINE_STATIC_KEY_FALSE(false_key);
|
|
|
|
/* external */
|
|
extern struct static_key base_old_true_key;
|
|
extern struct static_key base_inv_old_true_key;
|
|
extern struct static_key base_old_false_key;
|
|
extern struct static_key base_inv_old_false_key;
|
|
|
|
/* new api */
|
|
extern struct static_key_true base_true_key;
|
|
extern struct static_key_true base_inv_true_key;
|
|
extern struct static_key_false base_false_key;
|
|
extern struct static_key_false base_inv_false_key;
|
|
|
|
|
|
struct test_key {
|
|
bool init_state;
|
|
struct static_key *key;
|
|
bool (*test_key)(void);
|
|
};
|
|
|
|
#define test_key_func(key, branch) \
|
|
static bool key ## _ ## branch(void) \
|
|
{ \
|
|
return branch(&key); \
|
|
}
|
|
|
|
static void invert_key(struct static_key *key)
|
|
{
|
|
if (static_key_enabled(key))
|
|
static_key_disable(key);
|
|
else
|
|
static_key_enable(key);
|
|
}
|
|
|
|
static void invert_keys(struct test_key *keys, int size)
|
|
{
|
|
struct static_key *previous = NULL;
|
|
int i;
|
|
|
|
for (i = 0; i < size; i++) {
|
|
if (previous != keys[i].key) {
|
|
invert_key(keys[i].key);
|
|
previous = keys[i].key;
|
|
}
|
|
}
|
|
}
|
|
|
|
static int verify_keys(struct test_key *keys, int size, bool invert)
|
|
{
|
|
int i;
|
|
bool ret, init;
|
|
|
|
for (i = 0; i < size; i++) {
|
|
ret = static_key_enabled(keys[i].key);
|
|
init = keys[i].init_state;
|
|
if (ret != (invert ? !init : init))
|
|
return -EINVAL;
|
|
ret = keys[i].test_key();
|
|
if (static_key_enabled(keys[i].key)) {
|
|
if (!ret)
|
|
return -EINVAL;
|
|
} else {
|
|
if (ret)
|
|
return -EINVAL;
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
test_key_func(old_true_key, static_key_true)
|
|
test_key_func(old_false_key, static_key_false)
|
|
test_key_func(true_key, static_branch_likely)
|
|
test_key_func(true_key, static_branch_unlikely)
|
|
test_key_func(false_key, static_branch_likely)
|
|
test_key_func(false_key, static_branch_unlikely)
|
|
test_key_func(base_old_true_key, static_key_true)
|
|
test_key_func(base_inv_old_true_key, static_key_true)
|
|
test_key_func(base_old_false_key, static_key_false)
|
|
test_key_func(base_inv_old_false_key, static_key_false)
|
|
test_key_func(base_true_key, static_branch_likely)
|
|
test_key_func(base_true_key, static_branch_unlikely)
|
|
test_key_func(base_inv_true_key, static_branch_likely)
|
|
test_key_func(base_inv_true_key, static_branch_unlikely)
|
|
test_key_func(base_false_key, static_branch_likely)
|
|
test_key_func(base_false_key, static_branch_unlikely)
|
|
test_key_func(base_inv_false_key, static_branch_likely)
|
|
test_key_func(base_inv_false_key, static_branch_unlikely)
|
|
|
|
static int __init test_static_key_init(void)
|
|
{
|
|
int ret;
|
|
int size;
|
|
|
|
struct test_key static_key_tests[] = {
|
|
/* internal keys - old keys */
|
|
{
|
|
.init_state = true,
|
|
.key = &old_true_key,
|
|
.test_key = &old_true_key_static_key_true,
|
|
},
|
|
{
|
|
.init_state = false,
|
|
.key = &old_false_key,
|
|
.test_key = &old_false_key_static_key_false,
|
|
},
|
|
/* internal keys - new keys */
|
|
{
|
|
.init_state = true,
|
|
.key = &true_key.key,
|
|
.test_key = &true_key_static_branch_likely,
|
|
},
|
|
{
|
|
.init_state = true,
|
|
.key = &true_key.key,
|
|
.test_key = &true_key_static_branch_unlikely,
|
|
},
|
|
{
|
|
.init_state = false,
|
|
.key = &false_key.key,
|
|
.test_key = &false_key_static_branch_likely,
|
|
},
|
|
{
|
|
.init_state = false,
|
|
.key = &false_key.key,
|
|
.test_key = &false_key_static_branch_unlikely,
|
|
},
|
|
/* external keys - old keys */
|
|
{
|
|
.init_state = true,
|
|
.key = &base_old_true_key,
|
|
.test_key = &base_old_true_key_static_key_true,
|
|
},
|
|
{
|
|
.init_state = false,
|
|
.key = &base_inv_old_true_key,
|
|
.test_key = &base_inv_old_true_key_static_key_true,
|
|
},
|
|
{
|
|
.init_state = false,
|
|
.key = &base_old_false_key,
|
|
.test_key = &base_old_false_key_static_key_false,
|
|
},
|
|
{
|
|
.init_state = true,
|
|
.key = &base_inv_old_false_key,
|
|
.test_key = &base_inv_old_false_key_static_key_false,
|
|
},
|
|
/* external keys - new keys */
|
|
{
|
|
.init_state = true,
|
|
.key = &base_true_key.key,
|
|
.test_key = &base_true_key_static_branch_likely,
|
|
},
|
|
{
|
|
.init_state = true,
|
|
.key = &base_true_key.key,
|
|
.test_key = &base_true_key_static_branch_unlikely,
|
|
},
|
|
{
|
|
.init_state = false,
|
|
.key = &base_inv_true_key.key,
|
|
.test_key = &base_inv_true_key_static_branch_likely,
|
|
},
|
|
{
|
|
.init_state = false,
|
|
.key = &base_inv_true_key.key,
|
|
.test_key = &base_inv_true_key_static_branch_unlikely,
|
|
},
|
|
{
|
|
.init_state = false,
|
|
.key = &base_false_key.key,
|
|
.test_key = &base_false_key_static_branch_likely,
|
|
},
|
|
{
|
|
.init_state = false,
|
|
.key = &base_false_key.key,
|
|
.test_key = &base_false_key_static_branch_unlikely,
|
|
},
|
|
{
|
|
.init_state = true,
|
|
.key = &base_inv_false_key.key,
|
|
.test_key = &base_inv_false_key_static_branch_likely,
|
|
},
|
|
{
|
|
.init_state = true,
|
|
.key = &base_inv_false_key.key,
|
|
.test_key = &base_inv_false_key_static_branch_unlikely,
|
|
},
|
|
};
|
|
|
|
size = ARRAY_SIZE(static_key_tests);
|
|
|
|
ret = verify_keys(static_key_tests, size, false);
|
|
if (ret)
|
|
goto out;
|
|
|
|
invert_keys(static_key_tests, size);
|
|
ret = verify_keys(static_key_tests, size, true);
|
|
if (ret)
|
|
goto out;
|
|
|
|
invert_keys(static_key_tests, size);
|
|
ret = verify_keys(static_key_tests, size, false);
|
|
if (ret)
|
|
goto out;
|
|
return 0;
|
|
out:
|
|
return ret;
|
|
}
|
|
|
|
static void __exit test_static_key_exit(void)
|
|
{
|
|
}
|
|
|
|
module_init(test_static_key_init);
|
|
module_exit(test_static_key_exit);
|
|
|
|
MODULE_AUTHOR("Jason Baron <jbaron@akamai.com>");
|
|
MODULE_LICENSE("GPL");
|