mirror of
https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git
synced 2024-08-26 02:39:48 +00:00
![kbuild test robot](/assets/img/avatar_default.png)
Signed-off-by: Fengguang Wu <fengguang.wu@intel.com> Cc: Jason Baron <jbaron@akamai.com> Cc: Linus Torvalds <torvalds@linux-foundation.org> Cc: Peter Zijlstra (Intel) <peterz@infradead.org> Cc: Peter Zijlstra <peterz@infradead.org> Cc: Thomas Gleixner <tglx@linutronix.de> Link: http://lkml.kernel.org/r/20150803184748.GA80634@lkp-ib04 Signed-off-by: Ingo Molnar <mingo@kernel.org>
225 lines
5.4 KiB
C
225 lines
5.4 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) \
|
|
({bool func(void) { return branch(key); } func; })
|
|
|
|
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;
|
|
}
|
|
|
|
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 = test_key_func(&old_true_key, static_key_true),
|
|
},
|
|
{
|
|
.init_state = false,
|
|
.key = &old_false_key,
|
|
.test_key = test_key_func(&old_false_key, static_key_false),
|
|
},
|
|
/* internal keys - new keys */
|
|
{
|
|
.init_state = true,
|
|
.key = &true_key.key,
|
|
.test_key = test_key_func(&true_key, static_branch_likely),
|
|
},
|
|
{
|
|
.init_state = true,
|
|
.key = &true_key.key,
|
|
.test_key = test_key_func(&true_key, static_branch_unlikely),
|
|
},
|
|
{
|
|
.init_state = false,
|
|
.key = &false_key.key,
|
|
.test_key = test_key_func(&false_key, static_branch_likely),
|
|
},
|
|
{
|
|
.init_state = false,
|
|
.key = &false_key.key,
|
|
.test_key = test_key_func(&false_key, static_branch_unlikely),
|
|
},
|
|
/* external keys - old keys */
|
|
{
|
|
.init_state = true,
|
|
.key = &base_old_true_key,
|
|
.test_key = test_key_func(&base_old_true_key, static_key_true),
|
|
},
|
|
{
|
|
.init_state = false,
|
|
.key = &base_inv_old_true_key,
|
|
.test_key = test_key_func(&base_inv_old_true_key, static_key_true),
|
|
},
|
|
{
|
|
.init_state = false,
|
|
.key = &base_old_false_key,
|
|
.test_key = test_key_func(&base_old_false_key, static_key_false),
|
|
},
|
|
{
|
|
.init_state = true,
|
|
.key = &base_inv_old_false_key,
|
|
.test_key = test_key_func(&base_inv_old_false_key, static_key_false),
|
|
},
|
|
/* external keys - new keys */
|
|
{
|
|
.init_state = true,
|
|
.key = &base_true_key.key,
|
|
.test_key = test_key_func(&base_true_key, static_branch_likely),
|
|
},
|
|
{
|
|
.init_state = true,
|
|
.key = &base_true_key.key,
|
|
.test_key = test_key_func(&base_true_key, static_branch_unlikely),
|
|
},
|
|
{
|
|
.init_state = false,
|
|
.key = &base_inv_true_key.key,
|
|
.test_key = test_key_func(&base_inv_true_key, static_branch_likely),
|
|
},
|
|
{
|
|
.init_state = false,
|
|
.key = &base_inv_true_key.key,
|
|
.test_key = test_key_func(&base_inv_true_key, static_branch_unlikely),
|
|
},
|
|
{
|
|
.init_state = false,
|
|
.key = &base_false_key.key,
|
|
.test_key = test_key_func(&base_false_key, static_branch_likely),
|
|
},
|
|
{
|
|
.init_state = false,
|
|
.key = &base_false_key.key,
|
|
.test_key = test_key_func(&base_false_key, static_branch_unlikely),
|
|
},
|
|
{
|
|
.init_state = true,
|
|
.key = &base_inv_false_key.key,
|
|
.test_key = test_key_func(&base_inv_false_key, static_branch_likely),
|
|
},
|
|
{
|
|
.init_state = true,
|
|
.key = &base_inv_false_key.key,
|
|
.test_key = test_key_func(&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");
|