4 * Copyright (C) 2009 Jason Baron <jbaron@redhat.com>
5 * Copyright (C) 2011 Peter Zijlstra <pzijlstr@redhat.com>
8 #include <linux/memory.h>
9 #include <linux/uaccess.h>
10 #include <linux/module.h>
11 #include <linux/list.h>
12 #include <linux/slab.h>
13 #include <linux/sort.h>
14 #include <linux/err.h>
15 #include <linux/static_key.h>
16 #include <linux/jump_label_ratelimit.h>
18 #ifdef HAVE_JUMP_LABEL
20 /* mutex to protect coming/going of the the jump_label table */
21 static DEFINE_MUTEX(jump_label_mutex);
23 void jump_label_lock(void)
25 mutex_lock(&jump_label_mutex);
28 void jump_label_unlock(void)
30 mutex_unlock(&jump_label_mutex);
33 static int jump_label_cmp(const void *a, const void *b)
35 const struct jump_entry *jea = a;
36 const struct jump_entry *jeb = b;
38 if (jea->key < jeb->key)
41 if (jea->key > jeb->key)
48 jump_label_sort_entries(struct jump_entry *start, struct jump_entry *stop)
52 size = (((unsigned long)stop - (unsigned long)start)
53 / sizeof(struct jump_entry));
54 sort(start, size, sizeof(struct jump_entry), jump_label_cmp, NULL);
57 static void jump_label_update(struct static_key *key, int enable);
59 void static_key_slow_inc(struct static_key *key)
61 if (atomic_inc_not_zero(&key->enabled))
65 if (atomic_read(&key->enabled) == 0) {
66 if (!jump_label_get_branch_default(key))
67 jump_label_update(key, JUMP_LABEL_ENABLE);
69 jump_label_update(key, JUMP_LABEL_DISABLE);
71 atomic_inc(&key->enabled);
74 EXPORT_SYMBOL_GPL(static_key_slow_inc);
76 static void __static_key_slow_dec(struct static_key *key,
77 unsigned long rate_limit, struct delayed_work *work)
79 if (!atomic_dec_and_mutex_lock(&key->enabled, &jump_label_mutex)) {
80 WARN(atomic_read(&key->enabled) < 0,
81 "jump label: negative count!\n");
86 atomic_inc(&key->enabled);
87 schedule_delayed_work(work, rate_limit);
89 if (!jump_label_get_branch_default(key))
90 jump_label_update(key, JUMP_LABEL_DISABLE);
92 jump_label_update(key, JUMP_LABEL_ENABLE);
97 static void jump_label_update_timeout(struct work_struct *work)
99 struct static_key_deferred *key =
100 container_of(work, struct static_key_deferred, work.work);
101 __static_key_slow_dec(&key->key, 0, NULL);
104 void static_key_slow_dec(struct static_key *key)
106 __static_key_slow_dec(key, 0, NULL);
108 EXPORT_SYMBOL_GPL(static_key_slow_dec);
110 void static_key_slow_dec_deferred(struct static_key_deferred *key)
112 __static_key_slow_dec(&key->key, key->timeout, &key->work);
114 EXPORT_SYMBOL_GPL(static_key_slow_dec_deferred);
116 void jump_label_rate_limit(struct static_key_deferred *key,
120 INIT_DELAYED_WORK(&key->work, jump_label_update_timeout);
122 EXPORT_SYMBOL_GPL(jump_label_rate_limit);
124 static int addr_conflict(struct jump_entry *entry, void *start, void *end)
126 if (entry->code <= (unsigned long)end &&
127 entry->code + JUMP_LABEL_NOP_SIZE > (unsigned long)start)
133 static int __jump_label_text_reserved(struct jump_entry *iter_start,
134 struct jump_entry *iter_stop, void *start, void *end)
136 struct jump_entry *iter;
139 while (iter < iter_stop) {
140 if (addr_conflict(iter, start, end))
149 * Update code which is definitely not currently executing.
150 * Architectures which need heavyweight synchronization to modify
151 * running code can override this to make the non-live update case
154 void __weak __init_or_module arch_jump_label_transform_static(struct jump_entry *entry,
155 enum jump_label_type type)
157 arch_jump_label_transform(entry, type);
160 static void __jump_label_update(struct static_key *key,
161 struct jump_entry *entry,
162 struct jump_entry *stop, int enable)
164 for (; (entry < stop) &&
165 (entry->key == (jump_label_t)(unsigned long)key);
168 * entry->code set to 0 invalidates module init text sections
169 * kernel_text_address() verifies we are not in core kernel
170 * init code, see jump_label_invalidate_module_init().
172 if (entry->code && kernel_text_address(entry->code))
173 arch_jump_label_transform(entry, enable);
177 static enum jump_label_type jump_label_type(struct static_key *key)
179 bool true_branch = jump_label_get_branch_default(key);
180 bool state = static_key_enabled(key);
182 if ((!true_branch && state) || (true_branch && !state))
183 return JUMP_LABEL_ENABLE;
185 return JUMP_LABEL_DISABLE;
188 void __init jump_label_init(void)
190 struct jump_entry *iter_start = __start___jump_table;
191 struct jump_entry *iter_stop = __stop___jump_table;
192 struct static_key *key = NULL;
193 struct jump_entry *iter;
196 jump_label_sort_entries(iter_start, iter_stop);
198 for (iter = iter_start; iter < iter_stop; iter++) {
199 struct static_key *iterk;
201 iterk = (struct static_key *)(unsigned long)iter->key;
202 arch_jump_label_transform_static(iter, jump_label_type(iterk));
208 * Set key->entries to iter, but preserve JUMP_LABEL_TRUE_BRANCH.
210 *((unsigned long *)&key->entries) += (unsigned long)iter;
211 #ifdef CONFIG_MODULES
218 #ifdef CONFIG_MODULES
220 struct static_key_mod {
221 struct static_key_mod *next;
222 struct jump_entry *entries;
226 static int __jump_label_mod_text_reserved(void *start, void *end)
230 mod = __module_text_address((unsigned long)start);
234 WARN_ON_ONCE(__module_text_address((unsigned long)end) != mod);
236 return __jump_label_text_reserved(mod->jump_entries,
237 mod->jump_entries + mod->num_jump_entries,
241 static void __jump_label_mod_update(struct static_key *key, int enable)
243 struct static_key_mod *mod = key->next;
246 struct module *m = mod->mod;
248 __jump_label_update(key, mod->entries,
249 m->jump_entries + m->num_jump_entries,
256 * apply_jump_label_nops - patch module jump labels with arch_get_jump_label_nop()
257 * @mod: module to patch
259 * Allow for run-time selection of the optimal nops. Before the module
260 * loads patch these with arch_get_jump_label_nop(), which is specified by
261 * the arch specific jump label code.
263 void jump_label_apply_nops(struct module *mod)
265 struct jump_entry *iter_start = mod->jump_entries;
266 struct jump_entry *iter_stop = iter_start + mod->num_jump_entries;
267 struct jump_entry *iter;
269 /* if the module doesn't have jump label entries, just return */
270 if (iter_start == iter_stop)
273 for (iter = iter_start; iter < iter_stop; iter++) {
274 arch_jump_label_transform_static(iter, JUMP_LABEL_DISABLE);
278 static int jump_label_add_module(struct module *mod)
280 struct jump_entry *iter_start = mod->jump_entries;
281 struct jump_entry *iter_stop = iter_start + mod->num_jump_entries;
282 struct jump_entry *iter;
283 struct static_key *key = NULL;
284 struct static_key_mod *jlm;
286 /* if the module doesn't have jump label entries, just return */
287 if (iter_start == iter_stop)
290 jump_label_sort_entries(iter_start, iter_stop);
292 for (iter = iter_start; iter < iter_stop; iter++) {
293 struct static_key *iterk;
295 iterk = (struct static_key *)(unsigned long)iter->key;
300 if (__module_address(iter->key) == mod) {
302 * Set key->entries to iter, but preserve JUMP_LABEL_TRUE_BRANCH.
304 *((unsigned long *)&key->entries) += (unsigned long)iter;
308 jlm = kzalloc(sizeof(struct static_key_mod), GFP_KERNEL);
313 jlm->next = key->next;
316 if (jump_label_type(key) == JUMP_LABEL_ENABLE)
317 __jump_label_update(key, iter, iter_stop, JUMP_LABEL_ENABLE);
323 static void jump_label_del_module(struct module *mod)
325 struct jump_entry *iter_start = mod->jump_entries;
326 struct jump_entry *iter_stop = iter_start + mod->num_jump_entries;
327 struct jump_entry *iter;
328 struct static_key *key = NULL;
329 struct static_key_mod *jlm, **prev;
331 for (iter = iter_start; iter < iter_stop; iter++) {
332 if (iter->key == (jump_label_t)(unsigned long)key)
335 key = (struct static_key *)(unsigned long)iter->key;
337 if (__module_address(iter->key) == mod)
343 while (jlm && jlm->mod != mod) {
355 static void jump_label_invalidate_module_init(struct module *mod)
357 struct jump_entry *iter_start = mod->jump_entries;
358 struct jump_entry *iter_stop = iter_start + mod->num_jump_entries;
359 struct jump_entry *iter;
361 for (iter = iter_start; iter < iter_stop; iter++) {
362 if (within_module_init(iter->code, mod))
368 jump_label_module_notify(struct notifier_block *self, unsigned long val,
371 struct module *mod = data;
375 case MODULE_STATE_COMING:
377 ret = jump_label_add_module(mod);
379 jump_label_del_module(mod);
382 case MODULE_STATE_GOING:
384 jump_label_del_module(mod);
387 case MODULE_STATE_LIVE:
389 jump_label_invalidate_module_init(mod);
394 return notifier_from_errno(ret);
397 struct notifier_block jump_label_module_nb = {
398 .notifier_call = jump_label_module_notify,
399 .priority = 1, /* higher than tracepoints */
402 static __init int jump_label_init_module(void)
404 return register_module_notifier(&jump_label_module_nb);
406 early_initcall(jump_label_init_module);
408 #endif /* CONFIG_MODULES */
411 * jump_label_text_reserved - check if addr range is reserved
412 * @start: start text addr
413 * @end: end text addr
415 * checks if the text addr located between @start and @end
416 * overlaps with any of the jump label patch addresses. Code
417 * that wants to modify kernel text should first verify that
418 * it does not overlap with any of the jump label addresses.
419 * Caller must hold jump_label_mutex.
421 * returns 1 if there is an overlap, 0 otherwise
423 int jump_label_text_reserved(void *start, void *end)
425 int ret = __jump_label_text_reserved(__start___jump_table,
426 __stop___jump_table, start, end);
431 #ifdef CONFIG_MODULES
432 ret = __jump_label_mod_text_reserved(start, end);
437 static void jump_label_update(struct static_key *key, int enable)
439 struct jump_entry *stop = __stop___jump_table;
440 struct jump_entry *entry = jump_label_get_entries(key);
442 #ifdef CONFIG_MODULES
443 struct module *mod = __module_address((unsigned long)key);
445 __jump_label_mod_update(key, enable);
448 stop = mod->jump_entries + mod->num_jump_entries;
450 /* if there are no users, entry can be NULL */
452 __jump_label_update(key, entry, stop, enable);