]> git.karo-electronics.de Git - karo-tx-linux.git/blob - kernel/jump_label.c
Merge branch 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/mason/linux...
[karo-tx-linux.git] / kernel / jump_label.c
1 /*
2  * jump label support
3  *
4  * Copyright (C) 2009 Jason Baron <jbaron@redhat.com>
5  * Copyright (C) 2011 Peter Zijlstra <pzijlstr@redhat.com>
6  *
7  */
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>
17
18 #ifdef HAVE_JUMP_LABEL
19
20 /* mutex to protect coming/going of the the jump_label table */
21 static DEFINE_MUTEX(jump_label_mutex);
22
23 void jump_label_lock(void)
24 {
25         mutex_lock(&jump_label_mutex);
26 }
27
28 void jump_label_unlock(void)
29 {
30         mutex_unlock(&jump_label_mutex);
31 }
32
33 static int jump_label_cmp(const void *a, const void *b)
34 {
35         const struct jump_entry *jea = a;
36         const struct jump_entry *jeb = b;
37
38         if (jea->key < jeb->key)
39                 return -1;
40
41         if (jea->key > jeb->key)
42                 return 1;
43
44         return 0;
45 }
46
47 static void
48 jump_label_sort_entries(struct jump_entry *start, struct jump_entry *stop)
49 {
50         unsigned long size;
51
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);
55 }
56
57 static void jump_label_update(struct static_key *key, int enable);
58
59 void static_key_slow_inc(struct static_key *key)
60 {
61         if (atomic_inc_not_zero(&key->enabled))
62                 return;
63
64         jump_label_lock();
65         if (atomic_read(&key->enabled) == 0) {
66                 if (!jump_label_get_branch_default(key))
67                         jump_label_update(key, JUMP_LABEL_ENABLE);
68                 else
69                         jump_label_update(key, JUMP_LABEL_DISABLE);
70         }
71         atomic_inc(&key->enabled);
72         jump_label_unlock();
73 }
74 EXPORT_SYMBOL_GPL(static_key_slow_inc);
75
76 static void __static_key_slow_dec(struct static_key *key,
77                 unsigned long rate_limit, struct delayed_work *work)
78 {
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");
82                 return;
83         }
84
85         if (rate_limit) {
86                 atomic_inc(&key->enabled);
87                 schedule_delayed_work(work, rate_limit);
88         } else {
89                 if (!jump_label_get_branch_default(key))
90                         jump_label_update(key, JUMP_LABEL_DISABLE);
91                 else
92                         jump_label_update(key, JUMP_LABEL_ENABLE);
93         }
94         jump_label_unlock();
95 }
96
97 static void jump_label_update_timeout(struct work_struct *work)
98 {
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);
102 }
103
104 void static_key_slow_dec(struct static_key *key)
105 {
106         __static_key_slow_dec(key, 0, NULL);
107 }
108 EXPORT_SYMBOL_GPL(static_key_slow_dec);
109
110 void static_key_slow_dec_deferred(struct static_key_deferred *key)
111 {
112         __static_key_slow_dec(&key->key, key->timeout, &key->work);
113 }
114 EXPORT_SYMBOL_GPL(static_key_slow_dec_deferred);
115
116 void jump_label_rate_limit(struct static_key_deferred *key,
117                 unsigned long rl)
118 {
119         key->timeout = rl;
120         INIT_DELAYED_WORK(&key->work, jump_label_update_timeout);
121 }
122 EXPORT_SYMBOL_GPL(jump_label_rate_limit);
123
124 static int addr_conflict(struct jump_entry *entry, void *start, void *end)
125 {
126         if (entry->code <= (unsigned long)end &&
127                 entry->code + JUMP_LABEL_NOP_SIZE > (unsigned long)start)
128                 return 1;
129
130         return 0;
131 }
132
133 static int __jump_label_text_reserved(struct jump_entry *iter_start,
134                 struct jump_entry *iter_stop, void *start, void *end)
135 {
136         struct jump_entry *iter;
137
138         iter = iter_start;
139         while (iter < iter_stop) {
140                 if (addr_conflict(iter, start, end))
141                         return 1;
142                 iter++;
143         }
144
145         return 0;
146 }
147
148 /* 
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
152  * cheaper.
153  */
154 void __weak __init_or_module arch_jump_label_transform_static(struct jump_entry *entry,
155                                             enum jump_label_type type)
156 {
157         arch_jump_label_transform(entry, type); 
158 }
159
160 static void __jump_label_update(struct static_key *key,
161                                 struct jump_entry *entry,
162                                 struct jump_entry *stop, int enable)
163 {
164         for (; (entry < stop) &&
165               (entry->key == (jump_label_t)(unsigned long)key);
166               entry++) {
167                 /*
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().
171                  */
172                 if (entry->code && kernel_text_address(entry->code))
173                         arch_jump_label_transform(entry, enable);
174         }
175 }
176
177 static enum jump_label_type jump_label_type(struct static_key *key)
178 {
179         bool true_branch = jump_label_get_branch_default(key);
180         bool state = static_key_enabled(key);
181
182         if ((!true_branch && state) || (true_branch && !state))
183                 return JUMP_LABEL_ENABLE;
184
185         return JUMP_LABEL_DISABLE;
186 }
187
188 void __init jump_label_init(void)
189 {
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;
194
195         jump_label_lock();
196         jump_label_sort_entries(iter_start, iter_stop);
197
198         for (iter = iter_start; iter < iter_stop; iter++) {
199                 struct static_key *iterk;
200
201                 iterk = (struct static_key *)(unsigned long)iter->key;
202                 arch_jump_label_transform_static(iter, jump_label_type(iterk));
203                 if (iterk == key)
204                         continue;
205
206                 key = iterk;
207                 /*
208                  * Set key->entries to iter, but preserve JUMP_LABEL_TRUE_BRANCH.
209                  */
210                 *((unsigned long *)&key->entries) += (unsigned long)iter;
211 #ifdef CONFIG_MODULES
212                 key->next = NULL;
213 #endif
214         }
215         jump_label_unlock();
216 }
217
218 #ifdef CONFIG_MODULES
219
220 struct static_key_mod {
221         struct static_key_mod *next;
222         struct jump_entry *entries;
223         struct module *mod;
224 };
225
226 static int __jump_label_mod_text_reserved(void *start, void *end)
227 {
228         struct module *mod;
229
230         mod = __module_text_address((unsigned long)start);
231         if (!mod)
232                 return 0;
233
234         WARN_ON_ONCE(__module_text_address((unsigned long)end) != mod);
235
236         return __jump_label_text_reserved(mod->jump_entries,
237                                 mod->jump_entries + mod->num_jump_entries,
238                                 start, end);
239 }
240
241 static void __jump_label_mod_update(struct static_key *key, int enable)
242 {
243         struct static_key_mod *mod = key->next;
244
245         while (mod) {
246                 struct module *m = mod->mod;
247
248                 __jump_label_update(key, mod->entries,
249                                     m->jump_entries + m->num_jump_entries,
250                                     enable);
251                 mod = mod->next;
252         }
253 }
254
255 /***
256  * apply_jump_label_nops - patch module jump labels with arch_get_jump_label_nop()
257  * @mod: module to patch
258  *
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.
262  */
263 void jump_label_apply_nops(struct module *mod)
264 {
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;
268
269         /* if the module doesn't have jump label entries, just return */
270         if (iter_start == iter_stop)
271                 return;
272
273         for (iter = iter_start; iter < iter_stop; iter++) {
274                 arch_jump_label_transform_static(iter, JUMP_LABEL_DISABLE);
275         }
276 }
277
278 static int jump_label_add_module(struct module *mod)
279 {
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;
285
286         /* if the module doesn't have jump label entries, just return */
287         if (iter_start == iter_stop)
288                 return 0;
289
290         jump_label_sort_entries(iter_start, iter_stop);
291
292         for (iter = iter_start; iter < iter_stop; iter++) {
293                 struct static_key *iterk;
294
295                 iterk = (struct static_key *)(unsigned long)iter->key;
296                 if (iterk == key)
297                         continue;
298
299                 key = iterk;
300                 if (__module_address(iter->key) == mod) {
301                         /*
302                          * Set key->entries to iter, but preserve JUMP_LABEL_TRUE_BRANCH.
303                          */
304                         *((unsigned long *)&key->entries) += (unsigned long)iter;
305                         key->next = NULL;
306                         continue;
307                 }
308                 jlm = kzalloc(sizeof(struct static_key_mod), GFP_KERNEL);
309                 if (!jlm)
310                         return -ENOMEM;
311                 jlm->mod = mod;
312                 jlm->entries = iter;
313                 jlm->next = key->next;
314                 key->next = jlm;
315
316                 if (jump_label_type(key) == JUMP_LABEL_ENABLE)
317                         __jump_label_update(key, iter, iter_stop, JUMP_LABEL_ENABLE);
318         }
319
320         return 0;
321 }
322
323 static void jump_label_del_module(struct module *mod)
324 {
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;
330
331         for (iter = iter_start; iter < iter_stop; iter++) {
332                 if (iter->key == (jump_label_t)(unsigned long)key)
333                         continue;
334
335                 key = (struct static_key *)(unsigned long)iter->key;
336
337                 if (__module_address(iter->key) == mod)
338                         continue;
339
340                 prev = &key->next;
341                 jlm = key->next;
342
343                 while (jlm && jlm->mod != mod) {
344                         prev = &jlm->next;
345                         jlm = jlm->next;
346                 }
347
348                 if (jlm) {
349                         *prev = jlm->next;
350                         kfree(jlm);
351                 }
352         }
353 }
354
355 static void jump_label_invalidate_module_init(struct module *mod)
356 {
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;
360
361         for (iter = iter_start; iter < iter_stop; iter++) {
362                 if (within_module_init(iter->code, mod))
363                         iter->code = 0;
364         }
365 }
366
367 static int
368 jump_label_module_notify(struct notifier_block *self, unsigned long val,
369                          void *data)
370 {
371         struct module *mod = data;
372         int ret = 0;
373
374         switch (val) {
375         case MODULE_STATE_COMING:
376                 jump_label_lock();
377                 ret = jump_label_add_module(mod);
378                 if (ret)
379                         jump_label_del_module(mod);
380                 jump_label_unlock();
381                 break;
382         case MODULE_STATE_GOING:
383                 jump_label_lock();
384                 jump_label_del_module(mod);
385                 jump_label_unlock();
386                 break;
387         case MODULE_STATE_LIVE:
388                 jump_label_lock();
389                 jump_label_invalidate_module_init(mod);
390                 jump_label_unlock();
391                 break;
392         }
393
394         return notifier_from_errno(ret);
395 }
396
397 struct notifier_block jump_label_module_nb = {
398         .notifier_call = jump_label_module_notify,
399         .priority = 1, /* higher than tracepoints */
400 };
401
402 static __init int jump_label_init_module(void)
403 {
404         return register_module_notifier(&jump_label_module_nb);
405 }
406 early_initcall(jump_label_init_module);
407
408 #endif /* CONFIG_MODULES */
409
410 /***
411  * jump_label_text_reserved - check if addr range is reserved
412  * @start: start text addr
413  * @end: end text addr
414  *
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.
420  *
421  * returns 1 if there is an overlap, 0 otherwise
422  */
423 int jump_label_text_reserved(void *start, void *end)
424 {
425         int ret = __jump_label_text_reserved(__start___jump_table,
426                         __stop___jump_table, start, end);
427
428         if (ret)
429                 return ret;
430
431 #ifdef CONFIG_MODULES
432         ret = __jump_label_mod_text_reserved(start, end);
433 #endif
434         return ret;
435 }
436
437 static void jump_label_update(struct static_key *key, int enable)
438 {
439         struct jump_entry *stop = __stop___jump_table;
440         struct jump_entry *entry = jump_label_get_entries(key);
441
442 #ifdef CONFIG_MODULES
443         struct module *mod = __module_address((unsigned long)key);
444
445         __jump_label_mod_update(key, enable);
446
447         if (mod)
448                 stop = mod->jump_entries + mod->num_jump_entries;
449 #endif
450         /* if there are no users, entry can be NULL */
451         if (entry)
452                 __jump_label_update(key, entry, stop, enable);
453 }
454
455 #endif