/* * 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");