Branch data Line data Source code
1 : : // SPDX-License-Identifier: GPL-2.0-or-later
2 : : /*
3 : : * Kernel Probes (KProbes)
4 : : * kernel/kprobes.c
5 : : *
6 : : * Copyright (C) IBM Corporation, 2002, 2004
7 : : *
8 : : * 2002-Oct Created by Vamsi Krishna S <vamsi_krishna@in.ibm.com> Kernel
9 : : * Probes initial implementation (includes suggestions from
10 : : * Rusty Russell).
11 : : * 2004-Aug Updated by Prasanna S Panchamukhi <prasanna@in.ibm.com> with
12 : : * hlists and exceptions notifier as suggested by Andi Kleen.
13 : : * 2004-July Suparna Bhattacharya <suparna@in.ibm.com> added jumper probes
14 : : * interface to access function arguments.
15 : : * 2004-Sep Prasanna S Panchamukhi <prasanna@in.ibm.com> Changed Kprobes
16 : : * exceptions notifier to be first on the priority list.
17 : : * 2005-May Hien Nguyen <hien@us.ibm.com>, Jim Keniston
18 : : * <jkenisto@us.ibm.com> and Prasanna S Panchamukhi
19 : : * <prasanna@in.ibm.com> added function-return probes.
20 : : */
21 : : #include <linux/kprobes.h>
22 : : #include <linux/hash.h>
23 : : #include <linux/init.h>
24 : : #include <linux/slab.h>
25 : : #include <linux/stddef.h>
26 : : #include <linux/export.h>
27 : : #include <linux/moduleloader.h>
28 : : #include <linux/kallsyms.h>
29 : : #include <linux/freezer.h>
30 : : #include <linux/seq_file.h>
31 : : #include <linux/debugfs.h>
32 : : #include <linux/sysctl.h>
33 : : #include <linux/kdebug.h>
34 : : #include <linux/memory.h>
35 : : #include <linux/ftrace.h>
36 : : #include <linux/cpu.h>
37 : : #include <linux/jump_label.h>
38 : :
39 : : #include <asm/sections.h>
40 : : #include <asm/cacheflush.h>
41 : : #include <asm/errno.h>
42 : : #include <linux/uaccess.h>
43 : :
44 : : #define KPROBE_HASH_BITS 6
45 : : #define KPROBE_TABLE_SIZE (1 << KPROBE_HASH_BITS)
46 : :
47 : :
48 : : static int kprobes_initialized;
49 : : static struct hlist_head kprobe_table[KPROBE_TABLE_SIZE];
50 : : static struct hlist_head kretprobe_inst_table[KPROBE_TABLE_SIZE];
51 : :
52 : : /* NOTE: change this value only with kprobe_mutex held */
53 : : static bool kprobes_all_disarmed;
54 : :
55 : : /* This protects kprobe_table and optimizing_list */
56 : : static DEFINE_MUTEX(kprobe_mutex);
57 : : static DEFINE_PER_CPU(struct kprobe *, kprobe_instance) = NULL;
58 : : static struct {
59 : : raw_spinlock_t lock ____cacheline_aligned_in_smp;
60 : : } kretprobe_table_locks[KPROBE_TABLE_SIZE];
61 : :
62 : 0 : kprobe_opcode_t * __weak kprobe_lookup_name(const char *name,
63 : : unsigned int __unused)
64 : : {
65 : 0 : return ((kprobe_opcode_t *)(kallsyms_lookup_name(name)));
66 : : }
67 : :
68 : : static raw_spinlock_t *kretprobe_table_lock_ptr(unsigned long hash)
69 : : {
70 : 3 : return &(kretprobe_table_locks[hash].lock);
71 : : }
72 : :
73 : : /* Blacklist -- list of struct kprobe_blacklist_entry */
74 : : static LIST_HEAD(kprobe_blacklist);
75 : :
76 : : #ifdef __ARCH_WANT_KPROBES_INSN_SLOT
77 : : /*
78 : : * kprobe->ainsn.insn points to the copy of the instruction to be
79 : : * single-stepped. x86_64, POWER4 and above have no-exec support and
80 : : * stepping on the instruction on a vmalloced/kmalloced/data page
81 : : * is a recipe for disaster
82 : : */
83 : : struct kprobe_insn_page {
84 : : struct list_head list;
85 : : kprobe_opcode_t *insns; /* Page of instruction slots */
86 : : struct kprobe_insn_cache *cache;
87 : : int nused;
88 : : int ngarbage;
89 : : char slot_used[];
90 : : };
91 : :
92 : : #define KPROBE_INSN_PAGE_SIZE(slots) \
93 : : (offsetof(struct kprobe_insn_page, slot_used) + \
94 : : (sizeof(char) * (slots)))
95 : :
96 : : static int slots_per_page(struct kprobe_insn_cache *c)
97 : : {
98 : 0 : return PAGE_SIZE/(c->insn_size * sizeof(kprobe_opcode_t));
99 : : }
100 : :
101 : : enum kprobe_slot_state {
102 : : SLOT_CLEAN = 0,
103 : : SLOT_DIRTY = 1,
104 : : SLOT_USED = 2,
105 : : };
106 : :
107 : 0 : void __weak *alloc_insn_page(void)
108 : : {
109 : 0 : return module_alloc(PAGE_SIZE);
110 : : }
111 : :
112 : 0 : void __weak free_insn_page(void *page)
113 : : {
114 : 0 : module_memfree(page);
115 : 0 : }
116 : :
117 : : struct kprobe_insn_cache kprobe_insn_slots = {
118 : : .mutex = __MUTEX_INITIALIZER(kprobe_insn_slots.mutex),
119 : : .alloc = alloc_insn_page,
120 : : .free = free_insn_page,
121 : : .pages = LIST_HEAD_INIT(kprobe_insn_slots.pages),
122 : : .insn_size = MAX_INSN_SIZE,
123 : : .nr_garbage = 0,
124 : : };
125 : : static int collect_garbage_slots(struct kprobe_insn_cache *c);
126 : :
127 : : /**
128 : : * __get_insn_slot() - Find a slot on an executable page for an instruction.
129 : : * We allocate an executable page if there's no room on existing ones.
130 : : */
131 : 0 : kprobe_opcode_t *__get_insn_slot(struct kprobe_insn_cache *c)
132 : : {
133 : : struct kprobe_insn_page *kip;
134 : : kprobe_opcode_t *slot = NULL;
135 : :
136 : : /* Since the slot array is not protected by rcu, we need a mutex */
137 : 0 : mutex_lock(&c->mutex);
138 : : retry:
139 : : rcu_read_lock();
140 : 0 : list_for_each_entry_rcu(kip, &c->pages, list) {
141 : 0 : if (kip->nused < slots_per_page(c)) {
142 : : int i;
143 : 0 : for (i = 0; i < slots_per_page(c); i++) {
144 : 0 : if (kip->slot_used[i] == SLOT_CLEAN) {
145 : 0 : kip->slot_used[i] = SLOT_USED;
146 : 0 : kip->nused++;
147 : 0 : slot = kip->insns + (i * c->insn_size);
148 : : rcu_read_unlock();
149 : : goto out;
150 : : }
151 : : }
152 : : /* kip->nused is broken. Fix it. */
153 : 0 : kip->nused = slots_per_page(c);
154 : 0 : WARN_ON(1);
155 : : }
156 : : }
157 : : rcu_read_unlock();
158 : :
159 : : /* If there are any garbage slots, collect it and try again. */
160 : 0 : if (c->nr_garbage && collect_garbage_slots(c) == 0)
161 : : goto retry;
162 : :
163 : : /* All out of space. Need to allocate a new page. */
164 : 0 : kip = kmalloc(KPROBE_INSN_PAGE_SIZE(slots_per_page(c)), GFP_KERNEL);
165 : 0 : if (!kip)
166 : : goto out;
167 : :
168 : : /*
169 : : * Use module_alloc so this page is within +/- 2GB of where the
170 : : * kernel image and loaded module images reside. This is required
171 : : * so x86_64 can correctly handle the %rip-relative fixups.
172 : : */
173 : 0 : kip->insns = c->alloc();
174 : 0 : if (!kip->insns) {
175 : 0 : kfree(kip);
176 : 0 : goto out;
177 : : }
178 : 0 : INIT_LIST_HEAD(&kip->list);
179 : 0 : memset(kip->slot_used, SLOT_CLEAN, slots_per_page(c));
180 : 0 : kip->slot_used[0] = SLOT_USED;
181 : 0 : kip->nused = 1;
182 : 0 : kip->ngarbage = 0;
183 : 0 : kip->cache = c;
184 : 0 : list_add_rcu(&kip->list, &c->pages);
185 : 0 : slot = kip->insns;
186 : : out:
187 : 0 : mutex_unlock(&c->mutex);
188 : 0 : return slot;
189 : : }
190 : :
191 : : /* Return 1 if all garbages are collected, otherwise 0. */
192 : 0 : static int collect_one_slot(struct kprobe_insn_page *kip, int idx)
193 : : {
194 : 0 : kip->slot_used[idx] = SLOT_CLEAN;
195 : 0 : kip->nused--;
196 : 0 : if (kip->nused == 0) {
197 : : /*
198 : : * Page is no longer in use. Free it unless
199 : : * it's the last one. We keep the last one
200 : : * so as not to have to set it up again the
201 : : * next time somebody inserts a probe.
202 : : */
203 : 0 : if (!list_is_singular(&kip->list)) {
204 : : list_del_rcu(&kip->list);
205 : 0 : synchronize_rcu();
206 : 0 : kip->cache->free(kip->insns);
207 : 0 : kfree(kip);
208 : : }
209 : : return 1;
210 : : }
211 : : return 0;
212 : : }
213 : :
214 : 0 : static int collect_garbage_slots(struct kprobe_insn_cache *c)
215 : : {
216 : : struct kprobe_insn_page *kip, *next;
217 : :
218 : : /* Ensure no-one is interrupted on the garbages */
219 : 0 : synchronize_rcu();
220 : :
221 : 0 : list_for_each_entry_safe(kip, next, &c->pages, list) {
222 : : int i;
223 : 0 : if (kip->ngarbage == 0)
224 : 0 : continue;
225 : 0 : kip->ngarbage = 0; /* we will collect all garbages */
226 : 0 : for (i = 0; i < slots_per_page(c); i++) {
227 : 0 : if (kip->slot_used[i] == SLOT_DIRTY && collect_one_slot(kip, i))
228 : : break;
229 : : }
230 : : }
231 : 0 : c->nr_garbage = 0;
232 : 0 : return 0;
233 : : }
234 : :
235 : 0 : void __free_insn_slot(struct kprobe_insn_cache *c,
236 : : kprobe_opcode_t *slot, int dirty)
237 : : {
238 : : struct kprobe_insn_page *kip;
239 : : long idx;
240 : :
241 : 0 : mutex_lock(&c->mutex);
242 : : rcu_read_lock();
243 : 0 : list_for_each_entry_rcu(kip, &c->pages, list) {
244 : 0 : idx = ((long)slot - (long)kip->insns) /
245 : 0 : (c->insn_size * sizeof(kprobe_opcode_t));
246 : 0 : if (idx >= 0 && idx < slots_per_page(c))
247 : : goto out;
248 : : }
249 : : /* Could not find this slot. */
250 : 0 : WARN_ON(1);
251 : : kip = NULL;
252 : : out:
253 : : rcu_read_unlock();
254 : : /* Mark and sweep: this may sleep */
255 : 0 : if (kip) {
256 : : /* Check double free */
257 : 0 : WARN_ON(kip->slot_used[idx] != SLOT_USED);
258 : 0 : if (dirty) {
259 : 0 : kip->slot_used[idx] = SLOT_DIRTY;
260 : 0 : kip->ngarbage++;
261 : 0 : if (++c->nr_garbage > slots_per_page(c))
262 : 0 : collect_garbage_slots(c);
263 : : } else {
264 : 0 : collect_one_slot(kip, idx);
265 : : }
266 : : }
267 : 0 : mutex_unlock(&c->mutex);
268 : 0 : }
269 : :
270 : : /*
271 : : * Check given address is on the page of kprobe instruction slots.
272 : : * This will be used for checking whether the address on a stack
273 : : * is on a text area or not.
274 : : */
275 : 0 : bool __is_insn_slot_addr(struct kprobe_insn_cache *c, unsigned long addr)
276 : : {
277 : : struct kprobe_insn_page *kip;
278 : : bool ret = false;
279 : :
280 : : rcu_read_lock();
281 : 0 : list_for_each_entry_rcu(kip, &c->pages, list) {
282 : 0 : if (addr >= (unsigned long)kip->insns &&
283 : 0 : addr < (unsigned long)kip->insns + PAGE_SIZE) {
284 : : ret = true;
285 : : break;
286 : : }
287 : : }
288 : : rcu_read_unlock();
289 : :
290 : 0 : return ret;
291 : : }
292 : :
293 : : #ifdef CONFIG_OPTPROBES
294 : : /* For optimized_kprobe buffer */
295 : : struct kprobe_insn_cache kprobe_optinsn_slots = {
296 : : .mutex = __MUTEX_INITIALIZER(kprobe_optinsn_slots.mutex),
297 : : .alloc = alloc_insn_page,
298 : : .free = free_insn_page,
299 : : .pages = LIST_HEAD_INIT(kprobe_optinsn_slots.pages),
300 : : /* .insn_size is initialized later */
301 : : .nr_garbage = 0,
302 : : };
303 : : #endif
304 : : #endif
305 : :
306 : : /* We have preemption disabled.. so it is safe to use __ versions */
307 : : static inline void set_kprobe_instance(struct kprobe *kp)
308 : : {
309 : 0 : __this_cpu_write(kprobe_instance, kp);
310 : : }
311 : :
312 : : static inline void reset_kprobe_instance(void)
313 : : {
314 : 0 : __this_cpu_write(kprobe_instance, NULL);
315 : : }
316 : :
317 : : /*
318 : : * This routine is called either:
319 : : * - under the kprobe_mutex - during kprobe_[un]register()
320 : : * OR
321 : : * - with preemption disabled - from arch/xxx/kernel/kprobes.c
322 : : */
323 : 0 : struct kprobe *get_kprobe(void *addr)
324 : : {
325 : : struct hlist_head *head;
326 : : struct kprobe *p;
327 : :
328 : : head = &kprobe_table[hash_ptr(addr, KPROBE_HASH_BITS)];
329 : 0 : hlist_for_each_entry_rcu(p, head, hlist,
330 : : lockdep_is_held(&kprobe_mutex)) {
331 : 0 : if (p->addr == addr)
332 : 0 : return p;
333 : : }
334 : :
335 : : return NULL;
336 : : }
337 : : NOKPROBE_SYMBOL(get_kprobe);
338 : :
339 : : static int aggr_pre_handler(struct kprobe *p, struct pt_regs *regs);
340 : :
341 : : /* Return true if the kprobe is an aggregator */
342 : : static inline int kprobe_aggrprobe(struct kprobe *p)
343 : : {
344 : 0 : return p->pre_handler == aggr_pre_handler;
345 : : }
346 : :
347 : : /* Return true(!0) if the kprobe is unused */
348 : : static inline int kprobe_unused(struct kprobe *p)
349 : : {
350 : 0 : return kprobe_aggrprobe(p) && kprobe_disabled(p) &&
351 : 0 : list_empty(&p->list);
352 : : }
353 : :
354 : : /*
355 : : * Keep all fields in the kprobe consistent
356 : : */
357 : 0 : static inline void copy_kprobe(struct kprobe *ap, struct kprobe *p)
358 : : {
359 : 0 : memcpy(&p->opcode, &ap->opcode, sizeof(kprobe_opcode_t));
360 : 0 : memcpy(&p->ainsn, &ap->ainsn, sizeof(struct arch_specific_insn));
361 : 0 : }
362 : :
363 : : #ifdef CONFIG_OPTPROBES
364 : : /* NOTE: change this value only with kprobe_mutex held */
365 : : static bool kprobes_allow_optimization;
366 : :
367 : : /*
368 : : * Call all pre_handler on the list, but ignores its return value.
369 : : * This must be called from arch-dep optimized caller.
370 : : */
371 : 0 : void opt_pre_handler(struct kprobe *p, struct pt_regs *regs)
372 : : {
373 : : struct kprobe *kp;
374 : :
375 : 0 : list_for_each_entry_rcu(kp, &p->list, list) {
376 : 0 : if (kp->pre_handler && likely(!kprobe_disabled(kp))) {
377 : : set_kprobe_instance(kp);
378 : 0 : kp->pre_handler(kp, regs);
379 : : }
380 : : reset_kprobe_instance();
381 : : }
382 : 0 : }
383 : : NOKPROBE_SYMBOL(opt_pre_handler);
384 : :
385 : : /* Free optimized instructions and optimized_kprobe */
386 : 0 : static void free_aggr_kprobe(struct kprobe *p)
387 : : {
388 : : struct optimized_kprobe *op;
389 : :
390 : : op = container_of(p, struct optimized_kprobe, kp);
391 : 0 : arch_remove_optimized_kprobe(op);
392 : 0 : arch_remove_kprobe(p);
393 : 0 : kfree(op);
394 : 0 : }
395 : :
396 : : /* Return true(!0) if the kprobe is ready for optimization. */
397 : : static inline int kprobe_optready(struct kprobe *p)
398 : : {
399 : : struct optimized_kprobe *op;
400 : :
401 : 0 : if (kprobe_aggrprobe(p)) {
402 : : op = container_of(p, struct optimized_kprobe, kp);
403 : 0 : return arch_prepared_optinsn(&op->optinsn);
404 : : }
405 : :
406 : : return 0;
407 : : }
408 : :
409 : : /* Return true(!0) if the kprobe is disarmed. Note: p must be on hash list */
410 : : static inline int kprobe_disarmed(struct kprobe *p)
411 : : {
412 : : struct optimized_kprobe *op;
413 : :
414 : : /* If kprobe is not aggr/opt probe, just return kprobe is disabled */
415 : 0 : if (!kprobe_aggrprobe(p))
416 : : return kprobe_disabled(p);
417 : :
418 : : op = container_of(p, struct optimized_kprobe, kp);
419 : :
420 : 0 : return kprobe_disabled(p) && list_empty(&op->list);
421 : : }
422 : :
423 : : /* Return true(!0) if the probe is queued on (un)optimizing lists */
424 : : static int kprobe_queued(struct kprobe *p)
425 : : {
426 : : struct optimized_kprobe *op;
427 : :
428 : 0 : if (kprobe_aggrprobe(p)) {
429 : : op = container_of(p, struct optimized_kprobe, kp);
430 : 0 : if (!list_empty(&op->list))
431 : : return 1;
432 : : }
433 : : return 0;
434 : : }
435 : :
436 : : /*
437 : : * Return an optimized kprobe whose optimizing code replaces
438 : : * instructions including addr (exclude breakpoint).
439 : : */
440 : 0 : static struct kprobe *get_optimized_kprobe(unsigned long addr)
441 : : {
442 : : int i;
443 : : struct kprobe *p = NULL;
444 : : struct optimized_kprobe *op;
445 : :
446 : : /* Don't check i == 0, since that is a breakpoint case. */
447 : 0 : for (i = 1; !p && i < MAX_OPTIMIZED_LENGTH; i++)
448 : 0 : p = get_kprobe((void *)(addr - i));
449 : :
450 : 0 : if (p && kprobe_optready(p)) {
451 : 0 : op = container_of(p, struct optimized_kprobe, kp);
452 : 0 : if (arch_within_optimized_kprobe(op, addr))
453 : 0 : return p;
454 : : }
455 : :
456 : : return NULL;
457 : : }
458 : :
459 : : /* Optimization staging list, protected by kprobe_mutex */
460 : : static LIST_HEAD(optimizing_list);
461 : : static LIST_HEAD(unoptimizing_list);
462 : : static LIST_HEAD(freeing_list);
463 : :
464 : : static void kprobe_optimizer(struct work_struct *work);
465 : : static DECLARE_DELAYED_WORK(optimizing_work, kprobe_optimizer);
466 : : #define OPTIMIZE_DELAY 5
467 : :
468 : : /*
469 : : * Optimize (replace a breakpoint with a jump) kprobes listed on
470 : : * optimizing_list.
471 : : */
472 : 0 : static void do_optimize_kprobes(void)
473 : : {
474 : : lockdep_assert_held(&text_mutex);
475 : : /*
476 : : * The optimization/unoptimization refers online_cpus via
477 : : * stop_machine() and cpu-hotplug modifies online_cpus.
478 : : * And same time, text_mutex will be held in cpu-hotplug and here.
479 : : * This combination can cause a deadlock (cpu-hotplug try to lock
480 : : * text_mutex but stop_machine can not be done because online_cpus
481 : : * has been changed)
482 : : * To avoid this deadlock, caller must have locked cpu hotplug
483 : : * for preventing cpu-hotplug outside of text_mutex locking.
484 : : */
485 : : lockdep_assert_cpus_held();
486 : :
487 : : /* Optimization never be done when disarmed */
488 : 0 : if (kprobes_all_disarmed || !kprobes_allow_optimization ||
489 : : list_empty(&optimizing_list))
490 : 0 : return;
491 : :
492 : 0 : arch_optimize_kprobes(&optimizing_list);
493 : : }
494 : :
495 : : /*
496 : : * Unoptimize (replace a jump with a breakpoint and remove the breakpoint
497 : : * if need) kprobes listed on unoptimizing_list.
498 : : */
499 : 0 : static void do_unoptimize_kprobes(void)
500 : : {
501 : : struct optimized_kprobe *op, *tmp;
502 : :
503 : : lockdep_assert_held(&text_mutex);
504 : : /* See comment in do_optimize_kprobes() */
505 : : lockdep_assert_cpus_held();
506 : :
507 : : /* Unoptimization must be done anytime */
508 : 0 : if (list_empty(&unoptimizing_list))
509 : 0 : return;
510 : :
511 : 0 : arch_unoptimize_kprobes(&unoptimizing_list, &freeing_list);
512 : : /* Loop free_list for disarming */
513 : 0 : list_for_each_entry_safe(op, tmp, &freeing_list, list) {
514 : : /* Switching from detour code to origin */
515 : 0 : op->kp.flags &= ~KPROBE_FLAG_OPTIMIZED;
516 : : /* Disarm probes if marked disabled */
517 : 0 : if (kprobe_disabled(&op->kp))
518 : 0 : arch_disarm_kprobe(&op->kp);
519 : 0 : if (kprobe_unused(&op->kp)) {
520 : : /*
521 : : * Remove unused probes from hash list. After waiting
522 : : * for synchronization, these probes are reclaimed.
523 : : * (reclaiming is done by do_free_cleaned_kprobes.)
524 : : */
525 : : hlist_del_rcu(&op->kp.hlist);
526 : : } else
527 : : list_del_init(&op->list);
528 : : }
529 : : }
530 : :
531 : : /* Reclaim all kprobes on the free_list */
532 : 0 : static void do_free_cleaned_kprobes(void)
533 : : {
534 : : struct optimized_kprobe *op, *tmp;
535 : :
536 : 0 : list_for_each_entry_safe(op, tmp, &freeing_list, list) {
537 : : list_del_init(&op->list);
538 : 0 : if (WARN_ON_ONCE(!kprobe_unused(&op->kp))) {
539 : : /*
540 : : * This must not happen, but if there is a kprobe
541 : : * still in use, keep it on kprobes hash list.
542 : : */
543 : 0 : continue;
544 : : }
545 : 0 : free_aggr_kprobe(&op->kp);
546 : : }
547 : 0 : }
548 : :
549 : : /* Start optimizer after OPTIMIZE_DELAY passed */
550 : : static void kick_kprobe_optimizer(void)
551 : : {
552 : : schedule_delayed_work(&optimizing_work, OPTIMIZE_DELAY);
553 : : }
554 : :
555 : : /* Kprobe jump optimizer */
556 : 0 : static void kprobe_optimizer(struct work_struct *work)
557 : : {
558 : 0 : mutex_lock(&kprobe_mutex);
559 : : cpus_read_lock();
560 : 0 : mutex_lock(&text_mutex);
561 : : /* Lock modules while optimizing kprobes */
562 : 0 : mutex_lock(&module_mutex);
563 : :
564 : : /*
565 : : * Step 1: Unoptimize kprobes and collect cleaned (unused and disarmed)
566 : : * kprobes before waiting for quiesence period.
567 : : */
568 : 0 : do_unoptimize_kprobes();
569 : :
570 : : /*
571 : : * Step 2: Wait for quiesence period to ensure all potentially
572 : : * preempted tasks to have normally scheduled. Because optprobe
573 : : * may modify multiple instructions, there is a chance that Nth
574 : : * instruction is preempted. In that case, such tasks can return
575 : : * to 2nd-Nth byte of jump instruction. This wait is for avoiding it.
576 : : * Note that on non-preemptive kernel, this is transparently converted
577 : : * to synchronoze_sched() to wait for all interrupts to have completed.
578 : : */
579 : 0 : synchronize_rcu_tasks();
580 : :
581 : : /* Step 3: Optimize kprobes after quiesence period */
582 : 0 : do_optimize_kprobes();
583 : :
584 : : /* Step 4: Free cleaned kprobes after quiesence period */
585 : 0 : do_free_cleaned_kprobes();
586 : :
587 : 0 : mutex_unlock(&module_mutex);
588 : 0 : mutex_unlock(&text_mutex);
589 : : cpus_read_unlock();
590 : :
591 : : /* Step 5: Kick optimizer again if needed */
592 : 0 : if (!list_empty(&optimizing_list) || !list_empty(&unoptimizing_list))
593 : : kick_kprobe_optimizer();
594 : :
595 : 0 : mutex_unlock(&kprobe_mutex);
596 : 0 : }
597 : :
598 : : /* Wait for completing optimization and unoptimization */
599 : 0 : void wait_for_kprobe_optimizer(void)
600 : : {
601 : 0 : mutex_lock(&kprobe_mutex);
602 : :
603 : 0 : while (!list_empty(&optimizing_list) || !list_empty(&unoptimizing_list)) {
604 : 0 : mutex_unlock(&kprobe_mutex);
605 : :
606 : : /* this will also make optimizing_work execute immmediately */
607 : 0 : flush_delayed_work(&optimizing_work);
608 : : /* @optimizing_work might not have been queued yet, relax */
609 : 0 : cpu_relax();
610 : :
611 : 0 : mutex_lock(&kprobe_mutex);
612 : : }
613 : :
614 : 0 : mutex_unlock(&kprobe_mutex);
615 : 0 : }
616 : :
617 : : static bool optprobe_queued_unopt(struct optimized_kprobe *op)
618 : : {
619 : : struct optimized_kprobe *_op;
620 : :
621 : 0 : list_for_each_entry(_op, &unoptimizing_list, list) {
622 : 0 : if (op == _op)
623 : : return true;
624 : : }
625 : :
626 : : return false;
627 : : }
628 : :
629 : : /* Optimize kprobe if p is ready to be optimized */
630 : 0 : static void optimize_kprobe(struct kprobe *p)
631 : : {
632 : : struct optimized_kprobe *op;
633 : :
634 : : /* Check if the kprobe is disabled or not ready for optimization. */
635 : 0 : if (!kprobe_optready(p) || !kprobes_allow_optimization ||
636 : 0 : (kprobe_disabled(p) || kprobes_all_disarmed))
637 : : return;
638 : :
639 : : /* kprobes with post_handler can not be optimized */
640 : 0 : if (p->post_handler)
641 : : return;
642 : :
643 : : op = container_of(p, struct optimized_kprobe, kp);
644 : :
645 : : /* Check there is no other kprobes at the optimized instructions */
646 : 0 : if (arch_check_optimized_kprobe(op) < 0)
647 : : return;
648 : :
649 : : /* Check if it is already optimized. */
650 : 0 : if (op->kp.flags & KPROBE_FLAG_OPTIMIZED) {
651 : 0 : if (optprobe_queued_unopt(op)) {
652 : : /* This is under unoptimizing. Just dequeue the probe */
653 : 0 : list_del_init(&op->list);
654 : : }
655 : : return;
656 : : }
657 : 0 : op->kp.flags |= KPROBE_FLAG_OPTIMIZED;
658 : :
659 : : /* On unoptimizing/optimizing_list, op must have OPTIMIZED flag */
660 : 0 : if (WARN_ON_ONCE(!list_empty(&op->list)))
661 : : return;
662 : :
663 : : list_add(&op->list, &optimizing_list);
664 : : kick_kprobe_optimizer();
665 : : }
666 : :
667 : : /* Short cut to direct unoptimizing */
668 : 0 : static void force_unoptimize_kprobe(struct optimized_kprobe *op)
669 : : {
670 : : lockdep_assert_cpus_held();
671 : 0 : arch_unoptimize_kprobe(op);
672 : 0 : op->kp.flags &= ~KPROBE_FLAG_OPTIMIZED;
673 : 0 : if (kprobe_disabled(&op->kp))
674 : 0 : arch_disarm_kprobe(&op->kp);
675 : 0 : }
676 : :
677 : : /* Unoptimize a kprobe if p is optimized */
678 : 0 : static void unoptimize_kprobe(struct kprobe *p, bool force)
679 : : {
680 : : struct optimized_kprobe *op;
681 : :
682 : 0 : if (!kprobe_aggrprobe(p) || kprobe_disarmed(p))
683 : : return; /* This is not an optprobe nor optimized */
684 : :
685 : : op = container_of(p, struct optimized_kprobe, kp);
686 : 0 : if (!kprobe_optimized(p))
687 : : return;
688 : :
689 : 0 : if (!list_empty(&op->list)) {
690 : 0 : if (optprobe_queued_unopt(op)) {
691 : : /* Queued in unoptimizing queue */
692 : 0 : if (force) {
693 : : /*
694 : : * Forcibly unoptimize the kprobe here, and queue it
695 : : * in the freeing list for release afterwards.
696 : : */
697 : 0 : force_unoptimize_kprobe(op);
698 : : list_move(&op->list, &freeing_list);
699 : : }
700 : : } else {
701 : : /* Dequeue from the optimizing queue */
702 : : list_del_init(&op->list);
703 : 0 : op->kp.flags &= ~KPROBE_FLAG_OPTIMIZED;
704 : : }
705 : : return;
706 : : }
707 : :
708 : : /* Optimized kprobe case */
709 : 0 : if (force) {
710 : : /* Forcibly update the code: this is a special case */
711 : 0 : force_unoptimize_kprobe(op);
712 : : } else {
713 : : list_add(&op->list, &unoptimizing_list);
714 : : kick_kprobe_optimizer();
715 : : }
716 : : }
717 : :
718 : : /* Cancel unoptimizing for reusing */
719 : 0 : static int reuse_unused_kprobe(struct kprobe *ap)
720 : : {
721 : : struct optimized_kprobe *op;
722 : :
723 : : /*
724 : : * Unused kprobe MUST be on the way of delayed unoptimizing (means
725 : : * there is still a relative jump) and disabled.
726 : : */
727 : : op = container_of(ap, struct optimized_kprobe, kp);
728 : 0 : WARN_ON_ONCE(list_empty(&op->list));
729 : : /* Enable the probe again */
730 : 0 : ap->flags &= ~KPROBE_FLAG_DISABLED;
731 : : /* Optimize it again (remove from op->list) */
732 : 0 : if (!kprobe_optready(ap))
733 : : return -EINVAL;
734 : :
735 : 0 : optimize_kprobe(ap);
736 : 0 : return 0;
737 : : }
738 : :
739 : : /* Remove optimized instructions */
740 : 0 : static void kill_optimized_kprobe(struct kprobe *p)
741 : : {
742 : : struct optimized_kprobe *op;
743 : :
744 : : op = container_of(p, struct optimized_kprobe, kp);
745 : 0 : if (!list_empty(&op->list))
746 : : /* Dequeue from the (un)optimization queue */
747 : : list_del_init(&op->list);
748 : 0 : op->kp.flags &= ~KPROBE_FLAG_OPTIMIZED;
749 : :
750 : 0 : if (kprobe_unused(p)) {
751 : : /* Enqueue if it is unused */
752 : : list_add(&op->list, &freeing_list);
753 : : /*
754 : : * Remove unused probes from the hash list. After waiting
755 : : * for synchronization, this probe is reclaimed.
756 : : * (reclaiming is done by do_free_cleaned_kprobes().)
757 : : */
758 : : hlist_del_rcu(&op->kp.hlist);
759 : : }
760 : :
761 : : /* Don't touch the code, because it is already freed. */
762 : 0 : arch_remove_optimized_kprobe(op);
763 : 0 : }
764 : :
765 : : static inline
766 : : void __prepare_optimized_kprobe(struct optimized_kprobe *op, struct kprobe *p)
767 : : {
768 : 0 : if (!kprobe_ftrace(p))
769 : 0 : arch_prepare_optimized_kprobe(op, p);
770 : : }
771 : :
772 : : /* Try to prepare optimized instructions */
773 : : static void prepare_optimized_kprobe(struct kprobe *p)
774 : : {
775 : : struct optimized_kprobe *op;
776 : :
777 : : op = container_of(p, struct optimized_kprobe, kp);
778 : : __prepare_optimized_kprobe(op, p);
779 : : }
780 : :
781 : : /* Allocate new optimized_kprobe and try to prepare optimized instructions */
782 : 0 : static struct kprobe *alloc_aggr_kprobe(struct kprobe *p)
783 : : {
784 : : struct optimized_kprobe *op;
785 : :
786 : 0 : op = kzalloc(sizeof(struct optimized_kprobe), GFP_KERNEL);
787 : 0 : if (!op)
788 : : return NULL;
789 : :
790 : 0 : INIT_LIST_HEAD(&op->list);
791 : 0 : op->kp.addr = p->addr;
792 : : __prepare_optimized_kprobe(op, p);
793 : :
794 : 0 : return &op->kp;
795 : : }
796 : :
797 : : static void init_aggr_kprobe(struct kprobe *ap, struct kprobe *p);
798 : :
799 : : /*
800 : : * Prepare an optimized_kprobe and optimize it
801 : : * NOTE: p must be a normal registered kprobe
802 : : */
803 : 0 : static void try_to_optimize_kprobe(struct kprobe *p)
804 : : {
805 : : struct kprobe *ap;
806 : : struct optimized_kprobe *op;
807 : :
808 : : /* Impossible to optimize ftrace-based kprobe */
809 : 0 : if (kprobe_ftrace(p))
810 : 0 : return;
811 : :
812 : : /* For preparing optimization, jump_label_text_reserved() is called */
813 : : cpus_read_lock();
814 : 0 : jump_label_lock();
815 : 0 : mutex_lock(&text_mutex);
816 : :
817 : 0 : ap = alloc_aggr_kprobe(p);
818 : 0 : if (!ap)
819 : : goto out;
820 : :
821 : : op = container_of(ap, struct optimized_kprobe, kp);
822 : 0 : if (!arch_prepared_optinsn(&op->optinsn)) {
823 : : /* If failed to setup optimizing, fallback to kprobe */
824 : 0 : arch_remove_optimized_kprobe(op);
825 : 0 : kfree(op);
826 : 0 : goto out;
827 : : }
828 : :
829 : 0 : init_aggr_kprobe(ap, p);
830 : 0 : optimize_kprobe(ap); /* This just kicks optimizer thread */
831 : :
832 : : out:
833 : 0 : mutex_unlock(&text_mutex);
834 : 0 : jump_label_unlock();
835 : : cpus_read_unlock();
836 : : }
837 : :
838 : : #ifdef CONFIG_SYSCTL
839 : 0 : static void optimize_all_kprobes(void)
840 : : {
841 : : struct hlist_head *head;
842 : : struct kprobe *p;
843 : : unsigned int i;
844 : :
845 : 0 : mutex_lock(&kprobe_mutex);
846 : : /* If optimization is already allowed, just return */
847 : 0 : if (kprobes_allow_optimization)
848 : : goto out;
849 : :
850 : : cpus_read_lock();
851 : 0 : kprobes_allow_optimization = true;
852 : 0 : for (i = 0; i < KPROBE_TABLE_SIZE; i++) {
853 : : head = &kprobe_table[i];
854 : 0 : hlist_for_each_entry_rcu(p, head, hlist)
855 : 0 : if (!kprobe_disabled(p))
856 : 0 : optimize_kprobe(p);
857 : : }
858 : : cpus_read_unlock();
859 : 0 : printk(KERN_INFO "Kprobes globally optimized\n");
860 : : out:
861 : 0 : mutex_unlock(&kprobe_mutex);
862 : 0 : }
863 : :
864 : 0 : static void unoptimize_all_kprobes(void)
865 : : {
866 : : struct hlist_head *head;
867 : : struct kprobe *p;
868 : : unsigned int i;
869 : :
870 : 0 : mutex_lock(&kprobe_mutex);
871 : : /* If optimization is already prohibited, just return */
872 : 0 : if (!kprobes_allow_optimization) {
873 : 0 : mutex_unlock(&kprobe_mutex);
874 : 0 : return;
875 : : }
876 : :
877 : : cpus_read_lock();
878 : 0 : kprobes_allow_optimization = false;
879 : 0 : for (i = 0; i < KPROBE_TABLE_SIZE; i++) {
880 : : head = &kprobe_table[i];
881 : 0 : hlist_for_each_entry_rcu(p, head, hlist) {
882 : 0 : if (!kprobe_disabled(p))
883 : 0 : unoptimize_kprobe(p, false);
884 : : }
885 : : }
886 : : cpus_read_unlock();
887 : 0 : mutex_unlock(&kprobe_mutex);
888 : :
889 : : /* Wait for unoptimizing completion */
890 : 0 : wait_for_kprobe_optimizer();
891 : 0 : printk(KERN_INFO "Kprobes globally unoptimized\n");
892 : : }
893 : :
894 : : static DEFINE_MUTEX(kprobe_sysctl_mutex);
895 : : int sysctl_kprobes_optimization;
896 : 0 : int proc_kprobes_optimization_handler(struct ctl_table *table, int write,
897 : : void __user *buffer, size_t *length,
898 : : loff_t *ppos)
899 : : {
900 : : int ret;
901 : :
902 : 0 : mutex_lock(&kprobe_sysctl_mutex);
903 : 0 : sysctl_kprobes_optimization = kprobes_allow_optimization ? 1 : 0;
904 : 0 : ret = proc_dointvec_minmax(table, write, buffer, length, ppos);
905 : :
906 : 0 : if (sysctl_kprobes_optimization)
907 : 0 : optimize_all_kprobes();
908 : : else
909 : 0 : unoptimize_all_kprobes();
910 : 0 : mutex_unlock(&kprobe_sysctl_mutex);
911 : :
912 : 0 : return ret;
913 : : }
914 : : #endif /* CONFIG_SYSCTL */
915 : :
916 : : /* Put a breakpoint for a probe. Must be called with text_mutex locked */
917 : 0 : static void __arm_kprobe(struct kprobe *p)
918 : : {
919 : : struct kprobe *_p;
920 : :
921 : : /* Check collision with other optimized kprobes */
922 : 0 : _p = get_optimized_kprobe((unsigned long)p->addr);
923 : 0 : if (unlikely(_p))
924 : : /* Fallback to unoptimized kprobe */
925 : 0 : unoptimize_kprobe(_p, true);
926 : :
927 : 0 : arch_arm_kprobe(p);
928 : 0 : optimize_kprobe(p); /* Try to optimize (add kprobe to a list) */
929 : 0 : }
930 : :
931 : : /* Remove the breakpoint of a probe. Must be called with text_mutex locked */
932 : 0 : static void __disarm_kprobe(struct kprobe *p, bool reopt)
933 : : {
934 : : struct kprobe *_p;
935 : :
936 : : /* Try to unoptimize */
937 : 0 : unoptimize_kprobe(p, kprobes_all_disarmed);
938 : :
939 : 0 : if (!kprobe_queued(p)) {
940 : 0 : arch_disarm_kprobe(p);
941 : : /* If another kprobe was blocked, optimize it. */
942 : 0 : _p = get_optimized_kprobe((unsigned long)p->addr);
943 : 0 : if (unlikely(_p) && reopt)
944 : 0 : optimize_kprobe(_p);
945 : : }
946 : : /* TODO: reoptimize others after unoptimized this probe */
947 : 0 : }
948 : :
949 : : #else /* !CONFIG_OPTPROBES */
950 : :
951 : : #define optimize_kprobe(p) do {} while (0)
952 : : #define unoptimize_kprobe(p, f) do {} while (0)
953 : : #define kill_optimized_kprobe(p) do {} while (0)
954 : : #define prepare_optimized_kprobe(p) do {} while (0)
955 : : #define try_to_optimize_kprobe(p) do {} while (0)
956 : : #define __arm_kprobe(p) arch_arm_kprobe(p)
957 : : #define __disarm_kprobe(p, o) arch_disarm_kprobe(p)
958 : : #define kprobe_disarmed(p) kprobe_disabled(p)
959 : : #define wait_for_kprobe_optimizer() do {} while (0)
960 : :
961 : : static int reuse_unused_kprobe(struct kprobe *ap)
962 : : {
963 : : /*
964 : : * If the optimized kprobe is NOT supported, the aggr kprobe is
965 : : * released at the same time that the last aggregated kprobe is
966 : : * unregistered.
967 : : * Thus there should be no chance to reuse unused kprobe.
968 : : */
969 : : printk(KERN_ERR "Error: There should be no unused kprobe here.\n");
970 : : return -EINVAL;
971 : : }
972 : :
973 : : static void free_aggr_kprobe(struct kprobe *p)
974 : : {
975 : : arch_remove_kprobe(p);
976 : : kfree(p);
977 : : }
978 : :
979 : : static struct kprobe *alloc_aggr_kprobe(struct kprobe *p)
980 : : {
981 : : return kzalloc(sizeof(struct kprobe), GFP_KERNEL);
982 : : }
983 : : #endif /* CONFIG_OPTPROBES */
984 : :
985 : : #ifdef CONFIG_KPROBES_ON_FTRACE
986 : : static struct ftrace_ops kprobe_ftrace_ops __read_mostly = {
987 : : .func = kprobe_ftrace_handler,
988 : : .flags = FTRACE_OPS_FL_SAVE_REGS,
989 : : };
990 : :
991 : : static struct ftrace_ops kprobe_ipmodify_ops __read_mostly = {
992 : : .func = kprobe_ftrace_handler,
993 : : .flags = FTRACE_OPS_FL_SAVE_REGS | FTRACE_OPS_FL_IPMODIFY,
994 : : };
995 : :
996 : : static int kprobe_ipmodify_enabled;
997 : : static int kprobe_ftrace_enabled;
998 : :
999 : : /* Must ensure p->addr is really on ftrace */
1000 : : static int prepare_kprobe(struct kprobe *p)
1001 : : {
1002 : : if (!kprobe_ftrace(p))
1003 : : return arch_prepare_kprobe(p);
1004 : :
1005 : : return arch_prepare_kprobe_ftrace(p);
1006 : : }
1007 : :
1008 : : /* Caller must lock kprobe_mutex */
1009 : : static int __arm_kprobe_ftrace(struct kprobe *p, struct ftrace_ops *ops,
1010 : : int *cnt)
1011 : : {
1012 : : int ret = 0;
1013 : :
1014 : : ret = ftrace_set_filter_ip(ops, (unsigned long)p->addr, 0, 0);
1015 : : if (ret) {
1016 : : pr_debug("Failed to arm kprobe-ftrace at %pS (%d)\n",
1017 : : p->addr, ret);
1018 : : return ret;
1019 : : }
1020 : :
1021 : : if (*cnt == 0) {
1022 : : ret = register_ftrace_function(ops);
1023 : : if (ret) {
1024 : : pr_debug("Failed to init kprobe-ftrace (%d)\n", ret);
1025 : : goto err_ftrace;
1026 : : }
1027 : : }
1028 : :
1029 : : (*cnt)++;
1030 : : return ret;
1031 : :
1032 : : err_ftrace:
1033 : : /*
1034 : : * At this point, sinec ops is not registered, we should be sefe from
1035 : : * registering empty filter.
1036 : : */
1037 : : ftrace_set_filter_ip(ops, (unsigned long)p->addr, 1, 0);
1038 : : return ret;
1039 : : }
1040 : :
1041 : : static int arm_kprobe_ftrace(struct kprobe *p)
1042 : : {
1043 : : bool ipmodify = (p->post_handler != NULL);
1044 : :
1045 : : return __arm_kprobe_ftrace(p,
1046 : : ipmodify ? &kprobe_ipmodify_ops : &kprobe_ftrace_ops,
1047 : : ipmodify ? &kprobe_ipmodify_enabled : &kprobe_ftrace_enabled);
1048 : : }
1049 : :
1050 : : /* Caller must lock kprobe_mutex */
1051 : : static int __disarm_kprobe_ftrace(struct kprobe *p, struct ftrace_ops *ops,
1052 : : int *cnt)
1053 : : {
1054 : : int ret = 0;
1055 : :
1056 : : if (*cnt == 1) {
1057 : : ret = unregister_ftrace_function(ops);
1058 : : if (WARN(ret < 0, "Failed to unregister kprobe-ftrace (%d)\n", ret))
1059 : : return ret;
1060 : : }
1061 : :
1062 : : (*cnt)--;
1063 : :
1064 : : ret = ftrace_set_filter_ip(ops, (unsigned long)p->addr, 1, 0);
1065 : : WARN_ONCE(ret < 0, "Failed to disarm kprobe-ftrace at %pS (%d)\n",
1066 : : p->addr, ret);
1067 : : return ret;
1068 : : }
1069 : :
1070 : : static int disarm_kprobe_ftrace(struct kprobe *p)
1071 : : {
1072 : : bool ipmodify = (p->post_handler != NULL);
1073 : :
1074 : : return __disarm_kprobe_ftrace(p,
1075 : : ipmodify ? &kprobe_ipmodify_ops : &kprobe_ftrace_ops,
1076 : : ipmodify ? &kprobe_ipmodify_enabled : &kprobe_ftrace_enabled);
1077 : : }
1078 : : #else /* !CONFIG_KPROBES_ON_FTRACE */
1079 : : #define prepare_kprobe(p) arch_prepare_kprobe(p)
1080 : : #define arm_kprobe_ftrace(p) (-ENODEV)
1081 : : #define disarm_kprobe_ftrace(p) (-ENODEV)
1082 : : #endif
1083 : :
1084 : : /* Arm a kprobe with text_mutex */
1085 : 0 : static int arm_kprobe(struct kprobe *kp)
1086 : : {
1087 : 0 : if (unlikely(kprobe_ftrace(kp)))
1088 : : return arm_kprobe_ftrace(kp);
1089 : :
1090 : : cpus_read_lock();
1091 : 0 : mutex_lock(&text_mutex);
1092 : 0 : __arm_kprobe(kp);
1093 : 0 : mutex_unlock(&text_mutex);
1094 : : cpus_read_unlock();
1095 : :
1096 : 0 : return 0;
1097 : : }
1098 : :
1099 : : /* Disarm a kprobe with text_mutex */
1100 : 0 : static int disarm_kprobe(struct kprobe *kp, bool reopt)
1101 : : {
1102 : 0 : if (unlikely(kprobe_ftrace(kp)))
1103 : : return disarm_kprobe_ftrace(kp);
1104 : :
1105 : : cpus_read_lock();
1106 : 0 : mutex_lock(&text_mutex);
1107 : 0 : __disarm_kprobe(kp, reopt);
1108 : 0 : mutex_unlock(&text_mutex);
1109 : : cpus_read_unlock();
1110 : :
1111 : 0 : return 0;
1112 : : }
1113 : :
1114 : : /*
1115 : : * Aggregate handlers for multiple kprobes support - these handlers
1116 : : * take care of invoking the individual kprobe handlers on p->list
1117 : : */
1118 : 0 : static int aggr_pre_handler(struct kprobe *p, struct pt_regs *regs)
1119 : : {
1120 : : struct kprobe *kp;
1121 : :
1122 : 0 : list_for_each_entry_rcu(kp, &p->list, list) {
1123 : 0 : if (kp->pre_handler && likely(!kprobe_disabled(kp))) {
1124 : : set_kprobe_instance(kp);
1125 : 0 : if (kp->pre_handler(kp, regs))
1126 : : return 1;
1127 : : }
1128 : : reset_kprobe_instance();
1129 : : }
1130 : : return 0;
1131 : : }
1132 : : NOKPROBE_SYMBOL(aggr_pre_handler);
1133 : :
1134 : 0 : static void aggr_post_handler(struct kprobe *p, struct pt_regs *regs,
1135 : : unsigned long flags)
1136 : : {
1137 : : struct kprobe *kp;
1138 : :
1139 : 0 : list_for_each_entry_rcu(kp, &p->list, list) {
1140 : 0 : if (kp->post_handler && likely(!kprobe_disabled(kp))) {
1141 : : set_kprobe_instance(kp);
1142 : 0 : kp->post_handler(kp, regs, flags);
1143 : : reset_kprobe_instance();
1144 : : }
1145 : : }
1146 : 0 : }
1147 : : NOKPROBE_SYMBOL(aggr_post_handler);
1148 : :
1149 : 0 : static int aggr_fault_handler(struct kprobe *p, struct pt_regs *regs,
1150 : : int trapnr)
1151 : : {
1152 : 0 : struct kprobe *cur = __this_cpu_read(kprobe_instance);
1153 : :
1154 : : /*
1155 : : * if we faulted "during" the execution of a user specified
1156 : : * probe handler, invoke just that probe's fault handler
1157 : : */
1158 : 0 : if (cur && cur->fault_handler) {
1159 : 0 : if (cur->fault_handler(cur, regs, trapnr))
1160 : : return 1;
1161 : : }
1162 : : return 0;
1163 : : }
1164 : : NOKPROBE_SYMBOL(aggr_fault_handler);
1165 : :
1166 : : /* Walks the list and increments nmissed count for multiprobe case */
1167 : 0 : void kprobes_inc_nmissed_count(struct kprobe *p)
1168 : : {
1169 : : struct kprobe *kp;
1170 : 0 : if (!kprobe_aggrprobe(p)) {
1171 : 0 : p->nmissed++;
1172 : : } else {
1173 : 0 : list_for_each_entry_rcu(kp, &p->list, list)
1174 : 0 : kp->nmissed++;
1175 : : }
1176 : 0 : return;
1177 : : }
1178 : : NOKPROBE_SYMBOL(kprobes_inc_nmissed_count);
1179 : :
1180 : 0 : void recycle_rp_inst(struct kretprobe_instance *ri,
1181 : : struct hlist_head *head)
1182 : : {
1183 : 0 : struct kretprobe *rp = ri->rp;
1184 : :
1185 : : /* remove rp inst off the rprobe_inst_table */
1186 : : hlist_del(&ri->hlist);
1187 : : INIT_HLIST_NODE(&ri->hlist);
1188 : 0 : if (likely(rp)) {
1189 : 0 : raw_spin_lock(&rp->lock);
1190 : 0 : hlist_add_head(&ri->hlist, &rp->free_instances);
1191 : : raw_spin_unlock(&rp->lock);
1192 : : } else
1193 : : /* Unregistering */
1194 : 0 : hlist_add_head(&ri->hlist, head);
1195 : 0 : }
1196 : : NOKPROBE_SYMBOL(recycle_rp_inst);
1197 : :
1198 : 0 : void kretprobe_hash_lock(struct task_struct *tsk,
1199 : : struct hlist_head **head, unsigned long *flags)
1200 : : __acquires(hlist_lock)
1201 : : {
1202 : : unsigned long hash = hash_ptr(tsk, KPROBE_HASH_BITS);
1203 : : raw_spinlock_t *hlist_lock;
1204 : :
1205 : 0 : *head = &kretprobe_inst_table[hash];
1206 : : hlist_lock = kretprobe_table_lock_ptr(hash);
1207 : 0 : raw_spin_lock_irqsave(hlist_lock, *flags);
1208 : 0 : }
1209 : : NOKPROBE_SYMBOL(kretprobe_hash_lock);
1210 : :
1211 : 0 : static void kretprobe_table_lock(unsigned long hash,
1212 : : unsigned long *flags)
1213 : : __acquires(hlist_lock)
1214 : : {
1215 : : raw_spinlock_t *hlist_lock = kretprobe_table_lock_ptr(hash);
1216 : 3 : raw_spin_lock_irqsave(hlist_lock, *flags);
1217 : 0 : }
1218 : : NOKPROBE_SYMBOL(kretprobe_table_lock);
1219 : :
1220 : 0 : void kretprobe_hash_unlock(struct task_struct *tsk,
1221 : : unsigned long *flags)
1222 : : __releases(hlist_lock)
1223 : : {
1224 : : unsigned long hash = hash_ptr(tsk, KPROBE_HASH_BITS);
1225 : : raw_spinlock_t *hlist_lock;
1226 : :
1227 : : hlist_lock = kretprobe_table_lock_ptr(hash);
1228 : 0 : raw_spin_unlock_irqrestore(hlist_lock, *flags);
1229 : 0 : }
1230 : : NOKPROBE_SYMBOL(kretprobe_hash_unlock);
1231 : :
1232 : 0 : static void kretprobe_table_unlock(unsigned long hash,
1233 : : unsigned long *flags)
1234 : : __releases(hlist_lock)
1235 : : {
1236 : : raw_spinlock_t *hlist_lock = kretprobe_table_lock_ptr(hash);
1237 : 3 : raw_spin_unlock_irqrestore(hlist_lock, *flags);
1238 : 0 : }
1239 : : NOKPROBE_SYMBOL(kretprobe_table_unlock);
1240 : :
1241 : : struct kprobe kprobe_busy = {
1242 : : .addr = (void *) get_kprobe,
1243 : : };
1244 : :
1245 : 0 : void kprobe_busy_begin(void)
1246 : : {
1247 : : struct kprobe_ctlblk *kcb;
1248 : :
1249 : 3 : preempt_disable();
1250 : 3 : __this_cpu_write(current_kprobe, &kprobe_busy);
1251 : : kcb = get_kprobe_ctlblk();
1252 : 3 : kcb->kprobe_status = KPROBE_HIT_ACTIVE;
1253 : 0 : }
1254 : :
1255 : 0 : void kprobe_busy_end(void)
1256 : : {
1257 : 3 : __this_cpu_write(current_kprobe, NULL);
1258 : 3 : preempt_enable();
1259 : 0 : }
1260 : :
1261 : : /*
1262 : : * This function is called from finish_task_switch when task tk becomes dead,
1263 : : * so that we can recycle any function-return probe instances associated
1264 : : * with this task. These left over instances represent probed functions
1265 : : * that have been called but will never return.
1266 : : */
1267 : 3 : void kprobe_flush_task(struct task_struct *tk)
1268 : : {
1269 : : struct kretprobe_instance *ri;
1270 : : struct hlist_head *head, empty_rp;
1271 : : struct hlist_node *tmp;
1272 : : unsigned long hash, flags = 0;
1273 : :
1274 : 3 : if (unlikely(!kprobes_initialized))
1275 : : /* Early boot. kretprobe_table_locks not yet initialized. */
1276 : 0 : return;
1277 : :
1278 : : kprobe_busy_begin();
1279 : :
1280 : 3 : INIT_HLIST_HEAD(&empty_rp);
1281 : : hash = hash_ptr(tk, KPROBE_HASH_BITS);
1282 : : head = &kretprobe_inst_table[hash];
1283 : : kretprobe_table_lock(hash, &flags);
1284 : 3 : hlist_for_each_entry_safe(ri, tmp, head, hlist) {
1285 : 0 : if (ri->task == tk)
1286 : 0 : recycle_rp_inst(ri, &empty_rp);
1287 : : }
1288 : : kretprobe_table_unlock(hash, &flags);
1289 : 3 : hlist_for_each_entry_safe(ri, tmp, &empty_rp, hlist) {
1290 : : hlist_del(&ri->hlist);
1291 : 0 : kfree(ri);
1292 : : }
1293 : :
1294 : : kprobe_busy_end();
1295 : : }
1296 : : NOKPROBE_SYMBOL(kprobe_flush_task);
1297 : :
1298 : 0 : static inline void free_rp_inst(struct kretprobe *rp)
1299 : : {
1300 : : struct kretprobe_instance *ri;
1301 : : struct hlist_node *next;
1302 : :
1303 : 0 : hlist_for_each_entry_safe(ri, next, &rp->free_instances, hlist) {
1304 : : hlist_del(&ri->hlist);
1305 : 0 : kfree(ri);
1306 : : }
1307 : 0 : }
1308 : :
1309 : 0 : static void cleanup_rp_inst(struct kretprobe *rp)
1310 : : {
1311 : : unsigned long flags, hash;
1312 : : struct kretprobe_instance *ri;
1313 : : struct hlist_node *next;
1314 : : struct hlist_head *head;
1315 : :
1316 : : /* No race here */
1317 : 0 : for (hash = 0; hash < KPROBE_TABLE_SIZE; hash++) {
1318 : : kretprobe_table_lock(hash, &flags);
1319 : : head = &kretprobe_inst_table[hash];
1320 : 0 : hlist_for_each_entry_safe(ri, next, head, hlist) {
1321 : 0 : if (ri->rp == rp)
1322 : 0 : ri->rp = NULL;
1323 : : }
1324 : : kretprobe_table_unlock(hash, &flags);
1325 : : }
1326 : 0 : free_rp_inst(rp);
1327 : 0 : }
1328 : : NOKPROBE_SYMBOL(cleanup_rp_inst);
1329 : :
1330 : : /* Add the new probe to ap->list */
1331 : 0 : static int add_new_kprobe(struct kprobe *ap, struct kprobe *p)
1332 : : {
1333 : 0 : if (p->post_handler)
1334 : 0 : unoptimize_kprobe(ap, true); /* Fall back to normal kprobe */
1335 : :
1336 : 0 : list_add_rcu(&p->list, &ap->list);
1337 : 0 : if (p->post_handler && !ap->post_handler)
1338 : 0 : ap->post_handler = aggr_post_handler;
1339 : :
1340 : 0 : return 0;
1341 : : }
1342 : :
1343 : : /*
1344 : : * Fill in the required fields of the "manager kprobe". Replace the
1345 : : * earlier kprobe in the hlist with the manager kprobe
1346 : : */
1347 : 0 : static void init_aggr_kprobe(struct kprobe *ap, struct kprobe *p)
1348 : : {
1349 : : /* Copy p's insn slot to ap */
1350 : 0 : copy_kprobe(p, ap);
1351 : : flush_insn_slot(ap);
1352 : 0 : ap->addr = p->addr;
1353 : 0 : ap->flags = p->flags & ~KPROBE_FLAG_OPTIMIZED;
1354 : 0 : ap->pre_handler = aggr_pre_handler;
1355 : 0 : ap->fault_handler = aggr_fault_handler;
1356 : : /* We don't care the kprobe which has gone. */
1357 : 0 : if (p->post_handler && !kprobe_gone(p))
1358 : 0 : ap->post_handler = aggr_post_handler;
1359 : :
1360 : 0 : INIT_LIST_HEAD(&ap->list);
1361 : : INIT_HLIST_NODE(&ap->hlist);
1362 : :
1363 : 0 : list_add_rcu(&p->list, &ap->list);
1364 : 0 : hlist_replace_rcu(&p->hlist, &ap->hlist);
1365 : 0 : }
1366 : :
1367 : : /*
1368 : : * This is the second or subsequent kprobe at the address - handle
1369 : : * the intricacies
1370 : : */
1371 : 0 : static int register_aggr_kprobe(struct kprobe *orig_p, struct kprobe *p)
1372 : : {
1373 : : int ret = 0;
1374 : : struct kprobe *ap = orig_p;
1375 : :
1376 : : cpus_read_lock();
1377 : :
1378 : : /* For preparing optimization, jump_label_text_reserved() is called */
1379 : 0 : jump_label_lock();
1380 : 0 : mutex_lock(&text_mutex);
1381 : :
1382 : 0 : if (!kprobe_aggrprobe(orig_p)) {
1383 : : /* If orig_p is not an aggr_kprobe, create new aggr_kprobe. */
1384 : 0 : ap = alloc_aggr_kprobe(orig_p);
1385 : 0 : if (!ap) {
1386 : : ret = -ENOMEM;
1387 : : goto out;
1388 : : }
1389 : 0 : init_aggr_kprobe(ap, orig_p);
1390 : 0 : } else if (kprobe_unused(ap)) {
1391 : : /* This probe is going to die. Rescue it */
1392 : 0 : ret = reuse_unused_kprobe(ap);
1393 : 0 : if (ret)
1394 : : goto out;
1395 : : }
1396 : :
1397 : 0 : if (kprobe_gone(ap)) {
1398 : : /*
1399 : : * Attempting to insert new probe at the same location that
1400 : : * had a probe in the module vaddr area which already
1401 : : * freed. So, the instruction slot has already been
1402 : : * released. We need a new slot for the new probe.
1403 : : */
1404 : 0 : ret = arch_prepare_kprobe(ap);
1405 : 0 : if (ret)
1406 : : /*
1407 : : * Even if fail to allocate new slot, don't need to
1408 : : * free aggr_probe. It will be used next time, or
1409 : : * freed by unregister_kprobe.
1410 : : */
1411 : : goto out;
1412 : :
1413 : : /* Prepare optimized instructions if possible. */
1414 : : prepare_optimized_kprobe(ap);
1415 : :
1416 : : /*
1417 : : * Clear gone flag to prevent allocating new slot again, and
1418 : : * set disabled flag because it is not armed yet.
1419 : : */
1420 : 0 : ap->flags = (ap->flags & ~KPROBE_FLAG_GONE)
1421 : 0 : | KPROBE_FLAG_DISABLED;
1422 : : }
1423 : :
1424 : : /* Copy ap's insn slot to p */
1425 : 0 : copy_kprobe(ap, p);
1426 : 0 : ret = add_new_kprobe(ap, p);
1427 : :
1428 : : out:
1429 : 0 : mutex_unlock(&text_mutex);
1430 : 0 : jump_label_unlock();
1431 : : cpus_read_unlock();
1432 : :
1433 : 0 : if (ret == 0 && kprobe_disabled(ap) && !kprobe_disabled(p)) {
1434 : 0 : ap->flags &= ~KPROBE_FLAG_DISABLED;
1435 : 0 : if (!kprobes_all_disarmed) {
1436 : : /* Arm the breakpoint again. */
1437 : 0 : ret = arm_kprobe(ap);
1438 : 0 : if (ret) {
1439 : 0 : ap->flags |= KPROBE_FLAG_DISABLED;
1440 : : list_del_rcu(&p->list);
1441 : 0 : synchronize_rcu();
1442 : : }
1443 : : }
1444 : : }
1445 : 0 : return ret;
1446 : : }
1447 : :
1448 : 0 : bool __weak arch_within_kprobe_blacklist(unsigned long addr)
1449 : : {
1450 : : /* The __kprobes marked functions and entry code must not be probed */
1451 : 0 : return addr >= (unsigned long)__kprobes_text_start &&
1452 : 0 : addr < (unsigned long)__kprobes_text_end;
1453 : : }
1454 : :
1455 : 0 : static bool __within_kprobe_blacklist(unsigned long addr)
1456 : : {
1457 : : struct kprobe_blacklist_entry *ent;
1458 : :
1459 : 0 : if (arch_within_kprobe_blacklist(addr))
1460 : : return true;
1461 : : /*
1462 : : * If there exists a kprobe_blacklist, verify and
1463 : : * fail any probe registration in the prohibited area
1464 : : */
1465 : 0 : list_for_each_entry(ent, &kprobe_blacklist, list) {
1466 : 0 : if (addr >= ent->start_addr && addr < ent->end_addr)
1467 : : return true;
1468 : : }
1469 : : return false;
1470 : : }
1471 : :
1472 : 0 : bool within_kprobe_blacklist(unsigned long addr)
1473 : : {
1474 : : char symname[KSYM_NAME_LEN], *p;
1475 : :
1476 : 0 : if (__within_kprobe_blacklist(addr))
1477 : : return true;
1478 : :
1479 : : /* Check if the address is on a suffixed-symbol */
1480 : 0 : if (!lookup_symbol_name(addr, symname)) {
1481 : 0 : p = strchr(symname, '.');
1482 : 0 : if (!p)
1483 : : return false;
1484 : 0 : *p = '\0';
1485 : 0 : addr = (unsigned long)kprobe_lookup_name(symname, 0);
1486 : 0 : if (addr)
1487 : 0 : return __within_kprobe_blacklist(addr);
1488 : : }
1489 : : return false;
1490 : : }
1491 : :
1492 : : /*
1493 : : * If we have a symbol_name argument, look it up and add the offset field
1494 : : * to it. This way, we can specify a relative address to a symbol.
1495 : : * This returns encoded errors if it fails to look up symbol or invalid
1496 : : * combination of parameters.
1497 : : */
1498 : 0 : static kprobe_opcode_t *_kprobe_addr(kprobe_opcode_t *addr,
1499 : : const char *symbol_name, unsigned int offset)
1500 : : {
1501 : 0 : if ((symbol_name && addr) || (!symbol_name && !addr))
1502 : : goto invalid;
1503 : :
1504 : 0 : if (symbol_name) {
1505 : 0 : addr = kprobe_lookup_name(symbol_name, offset);
1506 : 0 : if (!addr)
1507 : : return ERR_PTR(-ENOENT);
1508 : : }
1509 : :
1510 : 0 : addr = (kprobe_opcode_t *)(((char *)addr) + offset);
1511 : 0 : if (addr)
1512 : 0 : return addr;
1513 : :
1514 : : invalid:
1515 : : return ERR_PTR(-EINVAL);
1516 : : }
1517 : :
1518 : : static kprobe_opcode_t *kprobe_addr(struct kprobe *p)
1519 : : {
1520 : 0 : return _kprobe_addr(p->addr, p->symbol_name, p->offset);
1521 : : }
1522 : :
1523 : : /* Check passed kprobe is valid and return kprobe in kprobe_table. */
1524 : 0 : static struct kprobe *__get_valid_kprobe(struct kprobe *p)
1525 : : {
1526 : : struct kprobe *ap, *list_p;
1527 : :
1528 : 0 : ap = get_kprobe(p->addr);
1529 : 0 : if (unlikely(!ap))
1530 : : return NULL;
1531 : :
1532 : 0 : if (p != ap) {
1533 : 0 : list_for_each_entry_rcu(list_p, &ap->list, list)
1534 : 0 : if (list_p == p)
1535 : : /* kprobe p is a valid probe */
1536 : : goto valid;
1537 : : return NULL;
1538 : : }
1539 : : valid:
1540 : 0 : return ap;
1541 : : }
1542 : :
1543 : : /* Return error if the kprobe is being re-registered */
1544 : 0 : static inline int check_kprobe_rereg(struct kprobe *p)
1545 : : {
1546 : : int ret = 0;
1547 : :
1548 : 0 : mutex_lock(&kprobe_mutex);
1549 : 0 : if (__get_valid_kprobe(p))
1550 : : ret = -EINVAL;
1551 : 0 : mutex_unlock(&kprobe_mutex);
1552 : :
1553 : 0 : return ret;
1554 : : }
1555 : :
1556 : 0 : int __weak arch_check_ftrace_location(struct kprobe *p)
1557 : : {
1558 : : unsigned long ftrace_addr;
1559 : :
1560 : 0 : ftrace_addr = ftrace_location((unsigned long)p->addr);
1561 : 0 : if (ftrace_addr) {
1562 : : #ifdef CONFIG_KPROBES_ON_FTRACE
1563 : : /* Given address is not on the instruction boundary */
1564 : : if ((unsigned long)p->addr != ftrace_addr)
1565 : : return -EILSEQ;
1566 : : p->flags |= KPROBE_FLAG_FTRACE;
1567 : : #else /* !CONFIG_KPROBES_ON_FTRACE */
1568 : : return -EINVAL;
1569 : : #endif
1570 : : }
1571 : 0 : return 0;
1572 : : }
1573 : :
1574 : 0 : static int check_kprobe_address_safe(struct kprobe *p,
1575 : : struct module **probed_mod)
1576 : : {
1577 : : int ret;
1578 : :
1579 : 0 : ret = arch_check_ftrace_location(p);
1580 : 0 : if (ret)
1581 : : return ret;
1582 : 0 : jump_label_lock();
1583 : 0 : preempt_disable();
1584 : :
1585 : : /* Ensure it is not in reserved area nor out of text */
1586 : 0 : if (!kernel_text_address((unsigned long) p->addr) ||
1587 : 0 : within_kprobe_blacklist((unsigned long) p->addr) ||
1588 : 0 : jump_label_text_reserved(p->addr, p->addr) ||
1589 : 0 : find_bug((unsigned long)p->addr)) {
1590 : : ret = -EINVAL;
1591 : : goto out;
1592 : : }
1593 : :
1594 : : /* Check if are we probing a module */
1595 : 0 : *probed_mod = __module_text_address((unsigned long) p->addr);
1596 : 0 : if (*probed_mod) {
1597 : : /*
1598 : : * We must hold a refcount of the probed module while updating
1599 : : * its code to prohibit unexpected unloading.
1600 : : */
1601 : 0 : if (unlikely(!try_module_get(*probed_mod))) {
1602 : : ret = -ENOENT;
1603 : : goto out;
1604 : : }
1605 : :
1606 : : /*
1607 : : * If the module freed .init.text, we couldn't insert
1608 : : * kprobes in there.
1609 : : */
1610 : 0 : if (within_module_init((unsigned long)p->addr, *probed_mod) &&
1611 : 0 : (*probed_mod)->state != MODULE_STATE_COMING) {
1612 : 0 : module_put(*probed_mod);
1613 : 0 : *probed_mod = NULL;
1614 : : ret = -ENOENT;
1615 : : }
1616 : : }
1617 : : out:
1618 : 0 : preempt_enable();
1619 : 0 : jump_label_unlock();
1620 : :
1621 : 0 : return ret;
1622 : : }
1623 : :
1624 : 0 : int register_kprobe(struct kprobe *p)
1625 : : {
1626 : : int ret;
1627 : : struct kprobe *old_p;
1628 : : struct module *probed_mod;
1629 : : kprobe_opcode_t *addr;
1630 : :
1631 : : /* Adjust probe address from symbol */
1632 : : addr = kprobe_addr(p);
1633 : 0 : if (IS_ERR(addr))
1634 : 0 : return PTR_ERR(addr);
1635 : 0 : p->addr = addr;
1636 : :
1637 : 0 : ret = check_kprobe_rereg(p);
1638 : 0 : if (ret)
1639 : : return ret;
1640 : :
1641 : : /* User can pass only KPROBE_FLAG_DISABLED to register_kprobe */
1642 : 0 : p->flags &= KPROBE_FLAG_DISABLED;
1643 : 0 : p->nmissed = 0;
1644 : 0 : INIT_LIST_HEAD(&p->list);
1645 : :
1646 : 0 : ret = check_kprobe_address_safe(p, &probed_mod);
1647 : 0 : if (ret)
1648 : : return ret;
1649 : :
1650 : 0 : mutex_lock(&kprobe_mutex);
1651 : :
1652 : 0 : old_p = get_kprobe(p->addr);
1653 : 0 : if (old_p) {
1654 : : /* Since this may unoptimize old_p, locking text_mutex. */
1655 : 0 : ret = register_aggr_kprobe(old_p, p);
1656 : 0 : goto out;
1657 : : }
1658 : :
1659 : : cpus_read_lock();
1660 : : /* Prevent text modification */
1661 : 0 : mutex_lock(&text_mutex);
1662 : 0 : ret = prepare_kprobe(p);
1663 : 0 : mutex_unlock(&text_mutex);
1664 : : cpus_read_unlock();
1665 : 0 : if (ret)
1666 : : goto out;
1667 : :
1668 : : INIT_HLIST_NODE(&p->hlist);
1669 : 0 : hlist_add_head_rcu(&p->hlist,
1670 : 0 : &kprobe_table[hash_ptr(p->addr, KPROBE_HASH_BITS)]);
1671 : :
1672 : 0 : if (!kprobes_all_disarmed && !kprobe_disabled(p)) {
1673 : 0 : ret = arm_kprobe(p);
1674 : 0 : if (ret) {
1675 : : hlist_del_rcu(&p->hlist);
1676 : 0 : synchronize_rcu();
1677 : 0 : goto out;
1678 : : }
1679 : : }
1680 : :
1681 : : /* Try to optimize kprobe */
1682 : 0 : try_to_optimize_kprobe(p);
1683 : : out:
1684 : 0 : mutex_unlock(&kprobe_mutex);
1685 : :
1686 : 0 : if (probed_mod)
1687 : 0 : module_put(probed_mod);
1688 : :
1689 : 0 : return ret;
1690 : : }
1691 : : EXPORT_SYMBOL_GPL(register_kprobe);
1692 : :
1693 : : /* Check if all probes on the aggrprobe are disabled */
1694 : : static int aggr_kprobe_disabled(struct kprobe *ap)
1695 : : {
1696 : : struct kprobe *kp;
1697 : :
1698 : 0 : list_for_each_entry_rcu(kp, &ap->list, list)
1699 : 0 : if (!kprobe_disabled(kp))
1700 : : /*
1701 : : * There is an active probe on the list.
1702 : : * We can't disable this ap.
1703 : : */
1704 : : return 0;
1705 : :
1706 : : return 1;
1707 : : }
1708 : :
1709 : : /* Disable one kprobe: Make sure called under kprobe_mutex is locked */
1710 : 0 : static struct kprobe *__disable_kprobe(struct kprobe *p)
1711 : : {
1712 : : struct kprobe *orig_p;
1713 : : int ret;
1714 : :
1715 : : /* Get an original kprobe for return */
1716 : 0 : orig_p = __get_valid_kprobe(p);
1717 : 0 : if (unlikely(orig_p == NULL))
1718 : : return ERR_PTR(-EINVAL);
1719 : :
1720 : 0 : if (!kprobe_disabled(p)) {
1721 : : /* Disable probe if it is a child probe */
1722 : 0 : if (p != orig_p)
1723 : 0 : p->flags |= KPROBE_FLAG_DISABLED;
1724 : :
1725 : : /* Try to disarm and disable this/parent probe */
1726 : 0 : if (p == orig_p || aggr_kprobe_disabled(orig_p)) {
1727 : : /*
1728 : : * If kprobes_all_disarmed is set, orig_p
1729 : : * should have already been disarmed, so
1730 : : * skip unneed disarming process.
1731 : : */
1732 : 0 : if (!kprobes_all_disarmed) {
1733 : 0 : ret = disarm_kprobe(orig_p, true);
1734 : 0 : if (ret) {
1735 : 0 : p->flags &= ~KPROBE_FLAG_DISABLED;
1736 : 0 : return ERR_PTR(ret);
1737 : : }
1738 : : }
1739 : 0 : orig_p->flags |= KPROBE_FLAG_DISABLED;
1740 : : }
1741 : : }
1742 : :
1743 : 0 : return orig_p;
1744 : : }
1745 : :
1746 : : /*
1747 : : * Unregister a kprobe without a scheduler synchronization.
1748 : : */
1749 : 0 : static int __unregister_kprobe_top(struct kprobe *p)
1750 : : {
1751 : : struct kprobe *ap, *list_p;
1752 : :
1753 : : /* Disable kprobe. This will disarm it if needed. */
1754 : 0 : ap = __disable_kprobe(p);
1755 : 0 : if (IS_ERR(ap))
1756 : 0 : return PTR_ERR(ap);
1757 : :
1758 : 0 : if (ap == p)
1759 : : /*
1760 : : * This probe is an independent(and non-optimized) kprobe
1761 : : * (not an aggrprobe). Remove from the hash list.
1762 : : */
1763 : : goto disarmed;
1764 : :
1765 : : /* Following process expects this probe is an aggrprobe */
1766 : 0 : WARN_ON(!kprobe_aggrprobe(ap));
1767 : :
1768 : 0 : if (list_is_singular(&ap->list) && kprobe_disarmed(ap))
1769 : : /*
1770 : : * !disarmed could be happen if the probe is under delayed
1771 : : * unoptimizing.
1772 : : */
1773 : : goto disarmed;
1774 : : else {
1775 : : /* If disabling probe has special handlers, update aggrprobe */
1776 : 0 : if (p->post_handler && !kprobe_gone(p)) {
1777 : 0 : list_for_each_entry_rcu(list_p, &ap->list, list) {
1778 : 0 : if ((list_p != p) && (list_p->post_handler))
1779 : : goto noclean;
1780 : : }
1781 : 0 : ap->post_handler = NULL;
1782 : : }
1783 : : noclean:
1784 : : /*
1785 : : * Remove from the aggrprobe: this path will do nothing in
1786 : : * __unregister_kprobe_bottom().
1787 : : */
1788 : : list_del_rcu(&p->list);
1789 : 0 : if (!kprobe_disabled(ap) && !kprobes_all_disarmed)
1790 : : /*
1791 : : * Try to optimize this probe again, because post
1792 : : * handler may have been changed.
1793 : : */
1794 : 0 : optimize_kprobe(ap);
1795 : : }
1796 : : return 0;
1797 : :
1798 : : disarmed:
1799 : : hlist_del_rcu(&ap->hlist);
1800 : 0 : return 0;
1801 : : }
1802 : :
1803 : 0 : static void __unregister_kprobe_bottom(struct kprobe *p)
1804 : : {
1805 : : struct kprobe *ap;
1806 : :
1807 : 0 : if (list_empty(&p->list))
1808 : : /* This is an independent kprobe */
1809 : 0 : arch_remove_kprobe(p);
1810 : 0 : else if (list_is_singular(&p->list)) {
1811 : : /* This is the last child of an aggrprobe */
1812 : 0 : ap = list_entry(p->list.next, struct kprobe, list);
1813 : : list_del(&p->list);
1814 : 0 : free_aggr_kprobe(ap);
1815 : : }
1816 : : /* Otherwise, do nothing. */
1817 : 0 : }
1818 : :
1819 : 0 : int register_kprobes(struct kprobe **kps, int num)
1820 : : {
1821 : : int i, ret = 0;
1822 : :
1823 : 0 : if (num <= 0)
1824 : : return -EINVAL;
1825 : 0 : for (i = 0; i < num; i++) {
1826 : 0 : ret = register_kprobe(kps[i]);
1827 : 0 : if (ret < 0) {
1828 : 0 : if (i > 0)
1829 : 0 : unregister_kprobes(kps, i);
1830 : : break;
1831 : : }
1832 : : }
1833 : 0 : return ret;
1834 : : }
1835 : : EXPORT_SYMBOL_GPL(register_kprobes);
1836 : :
1837 : 0 : void unregister_kprobe(struct kprobe *p)
1838 : : {
1839 : 0 : unregister_kprobes(&p, 1);
1840 : 0 : }
1841 : : EXPORT_SYMBOL_GPL(unregister_kprobe);
1842 : :
1843 : 0 : void unregister_kprobes(struct kprobe **kps, int num)
1844 : : {
1845 : : int i;
1846 : :
1847 : 0 : if (num <= 0)
1848 : 0 : return;
1849 : 0 : mutex_lock(&kprobe_mutex);
1850 : 0 : for (i = 0; i < num; i++)
1851 : 0 : if (__unregister_kprobe_top(kps[i]) < 0)
1852 : 0 : kps[i]->addr = NULL;
1853 : 0 : mutex_unlock(&kprobe_mutex);
1854 : :
1855 : 0 : synchronize_rcu();
1856 : 0 : for (i = 0; i < num; i++)
1857 : 0 : if (kps[i]->addr)
1858 : 0 : __unregister_kprobe_bottom(kps[i]);
1859 : : }
1860 : : EXPORT_SYMBOL_GPL(unregister_kprobes);
1861 : :
1862 : 0 : int __weak kprobe_exceptions_notify(struct notifier_block *self,
1863 : : unsigned long val, void *data)
1864 : : {
1865 : 0 : return NOTIFY_DONE;
1866 : : }
1867 : : NOKPROBE_SYMBOL(kprobe_exceptions_notify);
1868 : :
1869 : : static struct notifier_block kprobe_exceptions_nb = {
1870 : : .notifier_call = kprobe_exceptions_notify,
1871 : : .priority = 0x7fffffff /* we need to be notified first */
1872 : : };
1873 : :
1874 : 3 : unsigned long __weak arch_deref_entry_point(void *entry)
1875 : : {
1876 : 3 : return (unsigned long)entry;
1877 : : }
1878 : :
1879 : : #ifdef CONFIG_KRETPROBES
1880 : : /*
1881 : : * This kprobe pre_handler is registered with every kretprobe. When probe
1882 : : * hits it will set up the return probe.
1883 : : */
1884 : 0 : static int pre_handler_kretprobe(struct kprobe *p, struct pt_regs *regs)
1885 : : {
1886 : : struct kretprobe *rp = container_of(p, struct kretprobe, kp);
1887 : : unsigned long hash, flags = 0;
1888 : : struct kretprobe_instance *ri;
1889 : :
1890 : : /*
1891 : : * To avoid deadlocks, prohibit return probing in NMI contexts,
1892 : : * just skip the probe and increase the (inexact) 'nmissed'
1893 : : * statistical counter, so that the user is informed that
1894 : : * something happened:
1895 : : */
1896 : 0 : if (unlikely(in_nmi())) {
1897 : 0 : rp->nmissed++;
1898 : 0 : return 0;
1899 : : }
1900 : :
1901 : : /* TODO: consider to only swap the RA after the last pre_handler fired */
1902 : 0 : hash = hash_ptr(current, KPROBE_HASH_BITS);
1903 : 0 : raw_spin_lock_irqsave(&rp->lock, flags);
1904 : 0 : if (!hlist_empty(&rp->free_instances)) {
1905 : 0 : ri = hlist_entry(rp->free_instances.first,
1906 : : struct kretprobe_instance, hlist);
1907 : : hlist_del(&ri->hlist);
1908 : 0 : raw_spin_unlock_irqrestore(&rp->lock, flags);
1909 : :
1910 : 0 : ri->rp = rp;
1911 : 0 : ri->task = current;
1912 : :
1913 : 0 : if (rp->entry_handler && rp->entry_handler(ri, regs)) {
1914 : 0 : raw_spin_lock_irqsave(&rp->lock, flags);
1915 : 0 : hlist_add_head(&ri->hlist, &rp->free_instances);
1916 : 0 : raw_spin_unlock_irqrestore(&rp->lock, flags);
1917 : 0 : return 0;
1918 : : }
1919 : :
1920 : 0 : arch_prepare_kretprobe(ri, regs);
1921 : :
1922 : : /* XXX(hch): why is there no hlist_move_head? */
1923 : : INIT_HLIST_NODE(&ri->hlist);
1924 : : kretprobe_table_lock(hash, &flags);
1925 : 0 : hlist_add_head(&ri->hlist, &kretprobe_inst_table[hash]);
1926 : : kretprobe_table_unlock(hash, &flags);
1927 : : } else {
1928 : 0 : rp->nmissed++;
1929 : 0 : raw_spin_unlock_irqrestore(&rp->lock, flags);
1930 : : }
1931 : : return 0;
1932 : : }
1933 : : NOKPROBE_SYMBOL(pre_handler_kretprobe);
1934 : :
1935 : 0 : bool __weak arch_kprobe_on_func_entry(unsigned long offset)
1936 : : {
1937 : 0 : return !offset;
1938 : : }
1939 : :
1940 : 0 : bool kprobe_on_func_entry(kprobe_opcode_t *addr, const char *sym, unsigned long offset)
1941 : : {
1942 : 0 : kprobe_opcode_t *kp_addr = _kprobe_addr(addr, sym, offset);
1943 : :
1944 : 0 : if (IS_ERR(kp_addr))
1945 : : return false;
1946 : :
1947 : 0 : if (!kallsyms_lookup_size_offset((unsigned long)kp_addr, NULL, &offset) ||
1948 : 0 : !arch_kprobe_on_func_entry(offset))
1949 : : return false;
1950 : :
1951 : : return true;
1952 : : }
1953 : :
1954 : 0 : int register_kretprobe(struct kretprobe *rp)
1955 : : {
1956 : : int ret = 0;
1957 : : struct kretprobe_instance *inst;
1958 : : int i;
1959 : : void *addr;
1960 : :
1961 : 0 : if (!kprobe_on_func_entry(rp->kp.addr, rp->kp.symbol_name, rp->kp.offset))
1962 : : return -EINVAL;
1963 : :
1964 : : if (kretprobe_blacklist_size) {
1965 : : addr = kprobe_addr(&rp->kp);
1966 : : if (IS_ERR(addr))
1967 : : return PTR_ERR(addr);
1968 : :
1969 : : for (i = 0; kretprobe_blacklist[i].name != NULL; i++) {
1970 : : if (kretprobe_blacklist[i].addr == addr)
1971 : : return -EINVAL;
1972 : : }
1973 : : }
1974 : :
1975 : 0 : rp->kp.pre_handler = pre_handler_kretprobe;
1976 : 0 : rp->kp.post_handler = NULL;
1977 : 0 : rp->kp.fault_handler = NULL;
1978 : :
1979 : : /* Pre-allocate memory for max kretprobe instances */
1980 : 0 : if (rp->maxactive <= 0) {
1981 : : #ifdef CONFIG_PREEMPTION
1982 : : rp->maxactive = max_t(unsigned int, 10, 2*num_possible_cpus());
1983 : : #else
1984 : 0 : rp->maxactive = num_possible_cpus();
1985 : : #endif
1986 : : }
1987 : 0 : raw_spin_lock_init(&rp->lock);
1988 : 0 : INIT_HLIST_HEAD(&rp->free_instances);
1989 : 0 : for (i = 0; i < rp->maxactive; i++) {
1990 : 0 : inst = kmalloc(sizeof(struct kretprobe_instance) +
1991 : 0 : rp->data_size, GFP_KERNEL);
1992 : 0 : if (inst == NULL) {
1993 : 0 : free_rp_inst(rp);
1994 : 0 : return -ENOMEM;
1995 : : }
1996 : : INIT_HLIST_NODE(&inst->hlist);
1997 : 0 : hlist_add_head(&inst->hlist, &rp->free_instances);
1998 : : }
1999 : :
2000 : 0 : rp->nmissed = 0;
2001 : : /* Establish function entry probe point */
2002 : 0 : ret = register_kprobe(&rp->kp);
2003 : 0 : if (ret != 0)
2004 : 0 : free_rp_inst(rp);
2005 : 0 : return ret;
2006 : : }
2007 : : EXPORT_SYMBOL_GPL(register_kretprobe);
2008 : :
2009 : 0 : int register_kretprobes(struct kretprobe **rps, int num)
2010 : : {
2011 : : int ret = 0, i;
2012 : :
2013 : 0 : if (num <= 0)
2014 : : return -EINVAL;
2015 : 0 : for (i = 0; i < num; i++) {
2016 : 0 : ret = register_kretprobe(rps[i]);
2017 : 0 : if (ret < 0) {
2018 : 0 : if (i > 0)
2019 : 0 : unregister_kretprobes(rps, i);
2020 : : break;
2021 : : }
2022 : : }
2023 : 0 : return ret;
2024 : : }
2025 : : EXPORT_SYMBOL_GPL(register_kretprobes);
2026 : :
2027 : 0 : void unregister_kretprobe(struct kretprobe *rp)
2028 : : {
2029 : 0 : unregister_kretprobes(&rp, 1);
2030 : 0 : }
2031 : : EXPORT_SYMBOL_GPL(unregister_kretprobe);
2032 : :
2033 : 0 : void unregister_kretprobes(struct kretprobe **rps, int num)
2034 : : {
2035 : : int i;
2036 : :
2037 : 0 : if (num <= 0)
2038 : 0 : return;
2039 : 0 : mutex_lock(&kprobe_mutex);
2040 : 0 : for (i = 0; i < num; i++)
2041 : 0 : if (__unregister_kprobe_top(&rps[i]->kp) < 0)
2042 : 0 : rps[i]->kp.addr = NULL;
2043 : 0 : mutex_unlock(&kprobe_mutex);
2044 : :
2045 : 0 : synchronize_rcu();
2046 : 0 : for (i = 0; i < num; i++) {
2047 : 0 : if (rps[i]->kp.addr) {
2048 : 0 : __unregister_kprobe_bottom(&rps[i]->kp);
2049 : 0 : cleanup_rp_inst(rps[i]);
2050 : : }
2051 : : }
2052 : : }
2053 : : EXPORT_SYMBOL_GPL(unregister_kretprobes);
2054 : :
2055 : : #else /* CONFIG_KRETPROBES */
2056 : : int register_kretprobe(struct kretprobe *rp)
2057 : : {
2058 : : return -ENOSYS;
2059 : : }
2060 : : EXPORT_SYMBOL_GPL(register_kretprobe);
2061 : :
2062 : : int register_kretprobes(struct kretprobe **rps, int num)
2063 : : {
2064 : : return -ENOSYS;
2065 : : }
2066 : : EXPORT_SYMBOL_GPL(register_kretprobes);
2067 : :
2068 : : void unregister_kretprobe(struct kretprobe *rp)
2069 : : {
2070 : : }
2071 : : EXPORT_SYMBOL_GPL(unregister_kretprobe);
2072 : :
2073 : : void unregister_kretprobes(struct kretprobe **rps, int num)
2074 : : {
2075 : : }
2076 : : EXPORT_SYMBOL_GPL(unregister_kretprobes);
2077 : :
2078 : : static int pre_handler_kretprobe(struct kprobe *p, struct pt_regs *regs)
2079 : : {
2080 : : return 0;
2081 : : }
2082 : : NOKPROBE_SYMBOL(pre_handler_kretprobe);
2083 : :
2084 : : #endif /* CONFIG_KRETPROBES */
2085 : :
2086 : : /* Set the kprobe gone and remove its instruction buffer. */
2087 : 0 : static void kill_kprobe(struct kprobe *p)
2088 : : {
2089 : : struct kprobe *kp;
2090 : :
2091 : 0 : p->flags |= KPROBE_FLAG_GONE;
2092 : 0 : if (kprobe_aggrprobe(p)) {
2093 : : /*
2094 : : * If this is an aggr_kprobe, we have to list all the
2095 : : * chained probes and mark them GONE.
2096 : : */
2097 : 0 : list_for_each_entry_rcu(kp, &p->list, list)
2098 : 0 : kp->flags |= KPROBE_FLAG_GONE;
2099 : 0 : p->post_handler = NULL;
2100 : 0 : kill_optimized_kprobe(p);
2101 : : }
2102 : : /*
2103 : : * Here, we can remove insn_slot safely, because no thread calls
2104 : : * the original probed function (which will be freed soon) any more.
2105 : : */
2106 : 0 : arch_remove_kprobe(p);
2107 : :
2108 : : /*
2109 : : * The module is going away. We should disarm the kprobe which
2110 : : * is using ftrace.
2111 : : */
2112 : : if (kprobe_ftrace(p))
2113 : : disarm_kprobe_ftrace(p);
2114 : 0 : }
2115 : :
2116 : : /* Disable one kprobe */
2117 : 0 : int disable_kprobe(struct kprobe *kp)
2118 : : {
2119 : : int ret = 0;
2120 : : struct kprobe *p;
2121 : :
2122 : 0 : mutex_lock(&kprobe_mutex);
2123 : :
2124 : : /* Disable this kprobe */
2125 : 0 : p = __disable_kprobe(kp);
2126 : 0 : if (IS_ERR(p))
2127 : : ret = PTR_ERR(p);
2128 : :
2129 : 0 : mutex_unlock(&kprobe_mutex);
2130 : 0 : return ret;
2131 : : }
2132 : : EXPORT_SYMBOL_GPL(disable_kprobe);
2133 : :
2134 : : /* Enable one kprobe */
2135 : 0 : int enable_kprobe(struct kprobe *kp)
2136 : : {
2137 : : int ret = 0;
2138 : : struct kprobe *p;
2139 : :
2140 : 0 : mutex_lock(&kprobe_mutex);
2141 : :
2142 : : /* Check whether specified probe is valid. */
2143 : 0 : p = __get_valid_kprobe(kp);
2144 : 0 : if (unlikely(p == NULL)) {
2145 : : ret = -EINVAL;
2146 : : goto out;
2147 : : }
2148 : :
2149 : 0 : if (kprobe_gone(kp)) {
2150 : : /* This kprobe has gone, we couldn't enable it. */
2151 : : ret = -EINVAL;
2152 : : goto out;
2153 : : }
2154 : :
2155 : 0 : if (p != kp)
2156 : 0 : kp->flags &= ~KPROBE_FLAG_DISABLED;
2157 : :
2158 : 0 : if (!kprobes_all_disarmed && kprobe_disabled(p)) {
2159 : 0 : p->flags &= ~KPROBE_FLAG_DISABLED;
2160 : 0 : ret = arm_kprobe(p);
2161 : 0 : if (ret)
2162 : 0 : p->flags |= KPROBE_FLAG_DISABLED;
2163 : : }
2164 : : out:
2165 : 0 : mutex_unlock(&kprobe_mutex);
2166 : 0 : return ret;
2167 : : }
2168 : : EXPORT_SYMBOL_GPL(enable_kprobe);
2169 : :
2170 : : /* Caller must NOT call this in usual path. This is only for critical case */
2171 : 0 : void dump_kprobe(struct kprobe *kp)
2172 : : {
2173 : 0 : pr_err("Dumping kprobe:\n");
2174 : 0 : pr_err("Name: %s\nOffset: %x\nAddress: %pS\n",
2175 : : kp->symbol_name, kp->offset, kp->addr);
2176 : 0 : }
2177 : : NOKPROBE_SYMBOL(dump_kprobe);
2178 : :
2179 : 3 : int kprobe_add_ksym_blacklist(unsigned long entry)
2180 : : {
2181 : : struct kprobe_blacklist_entry *ent;
2182 : 3 : unsigned long offset = 0, size = 0;
2183 : :
2184 : 3 : if (!kernel_text_address(entry) ||
2185 : 3 : !kallsyms_lookup_size_offset(entry, &size, &offset))
2186 : : return -EINVAL;
2187 : :
2188 : : ent = kmalloc(sizeof(*ent), GFP_KERNEL);
2189 : 3 : if (!ent)
2190 : : return -ENOMEM;
2191 : 3 : ent->start_addr = entry;
2192 : 3 : ent->end_addr = entry + size;
2193 : 3 : INIT_LIST_HEAD(&ent->list);
2194 : : list_add_tail(&ent->list, &kprobe_blacklist);
2195 : :
2196 : 3 : return (int)size;
2197 : : }
2198 : :
2199 : : /* Add all symbols in given area into kprobe blacklist */
2200 : 3 : int kprobe_add_area_blacklist(unsigned long start, unsigned long end)
2201 : : {
2202 : : unsigned long entry;
2203 : : int ret = 0;
2204 : :
2205 : 3 : for (entry = start; entry < end; entry += ret) {
2206 : 3 : ret = kprobe_add_ksym_blacklist(entry);
2207 : 3 : if (ret < 0)
2208 : 0 : return ret;
2209 : 3 : if (ret == 0) /* In case of alias symbol */
2210 : : ret = 1;
2211 : : }
2212 : : return 0;
2213 : : }
2214 : :
2215 : 3 : int __init __weak arch_populate_kprobe_blacklist(void)
2216 : : {
2217 : 3 : return 0;
2218 : : }
2219 : :
2220 : : /*
2221 : : * Lookup and populate the kprobe_blacklist.
2222 : : *
2223 : : * Unlike the kretprobe blacklist, we'll need to determine
2224 : : * the range of addresses that belong to the said functions,
2225 : : * since a kprobe need not necessarily be at the beginning
2226 : : * of a function.
2227 : : */
2228 : 3 : static int __init populate_kprobe_blacklist(unsigned long *start,
2229 : : unsigned long *end)
2230 : : {
2231 : : unsigned long entry;
2232 : : unsigned long *iter;
2233 : : int ret;
2234 : :
2235 : 3 : for (iter = start; iter < end; iter++) {
2236 : 3 : entry = arch_deref_entry_point((void *)*iter);
2237 : 3 : ret = kprobe_add_ksym_blacklist(entry);
2238 : 3 : if (ret == -EINVAL)
2239 : 0 : continue;
2240 : 3 : if (ret < 0)
2241 : 0 : return ret;
2242 : : }
2243 : :
2244 : : /* Symbols in __kprobes_text are blacklisted */
2245 : 3 : ret = kprobe_add_area_blacklist((unsigned long)__kprobes_text_start,
2246 : : (unsigned long)__kprobes_text_end);
2247 : :
2248 : 3 : return ret ? : arch_populate_kprobe_blacklist();
2249 : : }
2250 : :
2251 : : /* Module notifier call back, checking kprobes on the module */
2252 : 3 : static int kprobes_module_callback(struct notifier_block *nb,
2253 : : unsigned long val, void *data)
2254 : : {
2255 : : struct module *mod = data;
2256 : : struct hlist_head *head;
2257 : : struct kprobe *p;
2258 : : unsigned int i;
2259 : : int checkcore = (val == MODULE_STATE_GOING);
2260 : :
2261 : 3 : if (val != MODULE_STATE_GOING && val != MODULE_STATE_LIVE)
2262 : : return NOTIFY_DONE;
2263 : :
2264 : : /*
2265 : : * When MODULE_STATE_GOING was notified, both of module .text and
2266 : : * .init.text sections would be freed. When MODULE_STATE_LIVE was
2267 : : * notified, only .init.text section would be freed. We need to
2268 : : * disable kprobes which have been inserted in the sections.
2269 : : */
2270 : 3 : mutex_lock(&kprobe_mutex);
2271 : 3 : for (i = 0; i < KPROBE_TABLE_SIZE; i++) {
2272 : : head = &kprobe_table[i];
2273 : 3 : hlist_for_each_entry_rcu(p, head, hlist)
2274 : 0 : if (within_module_init((unsigned long)p->addr, mod) ||
2275 : 0 : (checkcore &&
2276 : : within_module_core((unsigned long)p->addr, mod))) {
2277 : : /*
2278 : : * The vaddr this probe is installed will soon
2279 : : * be vfreed buy not synced to disk. Hence,
2280 : : * disarming the breakpoint isn't needed.
2281 : : *
2282 : : * Note, this will also move any optimized probes
2283 : : * that are pending to be removed from their
2284 : : * corresponding lists to the freeing_list and
2285 : : * will not be touched by the delayed
2286 : : * kprobe_optimizer work handler.
2287 : : */
2288 : 0 : kill_kprobe(p);
2289 : : }
2290 : : }
2291 : 3 : mutex_unlock(&kprobe_mutex);
2292 : 3 : return NOTIFY_DONE;
2293 : : }
2294 : :
2295 : : static struct notifier_block kprobe_module_nb = {
2296 : : .notifier_call = kprobes_module_callback,
2297 : : .priority = 0
2298 : : };
2299 : :
2300 : : /* Markers of _kprobe_blacklist section */
2301 : : extern unsigned long __start_kprobe_blacklist[];
2302 : : extern unsigned long __stop_kprobe_blacklist[];
2303 : :
2304 : 3 : static int __init init_kprobes(void)
2305 : : {
2306 : : int i, err = 0;
2307 : :
2308 : : /* FIXME allocate the probe table, currently defined statically */
2309 : : /* initialize all list heads */
2310 : 3 : for (i = 0; i < KPROBE_TABLE_SIZE; i++) {
2311 : 3 : INIT_HLIST_HEAD(&kprobe_table[i]);
2312 : 3 : INIT_HLIST_HEAD(&kretprobe_inst_table[i]);
2313 : 3 : raw_spin_lock_init(&(kretprobe_table_locks[i].lock));
2314 : : }
2315 : :
2316 : 3 : err = populate_kprobe_blacklist(__start_kprobe_blacklist,
2317 : : __stop_kprobe_blacklist);
2318 : 3 : if (err) {
2319 : 0 : pr_err("kprobes: failed to populate blacklist: %d\n", err);
2320 : 0 : pr_err("Please take care of using kprobes.\n");
2321 : : }
2322 : :
2323 : : if (kretprobe_blacklist_size) {
2324 : : /* lookup the function address from its name */
2325 : : for (i = 0; kretprobe_blacklist[i].name != NULL; i++) {
2326 : : kretprobe_blacklist[i].addr =
2327 : : kprobe_lookup_name(kretprobe_blacklist[i].name, 0);
2328 : : if (!kretprobe_blacklist[i].addr)
2329 : : printk("kretprobe: lookup failed: %s\n",
2330 : : kretprobe_blacklist[i].name);
2331 : : }
2332 : : }
2333 : :
2334 : : #if defined(CONFIG_OPTPROBES)
2335 : : #if defined(__ARCH_WANT_KPROBES_INSN_SLOT)
2336 : : /* Init kprobe_optinsn_slots */
2337 : 3 : kprobe_optinsn_slots.insn_size = MAX_OPTINSN_SIZE;
2338 : : #endif
2339 : : /* By default, kprobes can be optimized */
2340 : 3 : kprobes_allow_optimization = true;
2341 : : #endif
2342 : :
2343 : : /* By default, kprobes are armed */
2344 : 3 : kprobes_all_disarmed = false;
2345 : :
2346 : 3 : err = arch_init_kprobes();
2347 : 3 : if (!err)
2348 : 3 : err = register_die_notifier(&kprobe_exceptions_nb);
2349 : 3 : if (!err)
2350 : 3 : err = register_module_notifier(&kprobe_module_nb);
2351 : :
2352 : 3 : kprobes_initialized = (err == 0);
2353 : :
2354 : : if (!err)
2355 : : init_test_probes();
2356 : 3 : return err;
2357 : : }
2358 : : subsys_initcall(init_kprobes);
2359 : :
2360 : : #ifdef CONFIG_DEBUG_FS
2361 : 0 : static void report_probe(struct seq_file *pi, struct kprobe *p,
2362 : : const char *sym, int offset, char *modname, struct kprobe *pp)
2363 : : {
2364 : : char *kprobe_type;
2365 : 0 : void *addr = p->addr;
2366 : :
2367 : 0 : if (p->pre_handler == pre_handler_kretprobe)
2368 : : kprobe_type = "r";
2369 : : else
2370 : : kprobe_type = "k";
2371 : :
2372 : 0 : if (!kallsyms_show_value(pi->file->f_cred))
2373 : : addr = NULL;
2374 : :
2375 : 0 : if (sym)
2376 : 0 : seq_printf(pi, "%px %s %s+0x%x %s ",
2377 : : addr, kprobe_type, sym, offset,
2378 : : (modname ? modname : " "));
2379 : : else /* try to use %pS */
2380 : 0 : seq_printf(pi, "%px %s %pS ",
2381 : : addr, kprobe_type, p->addr);
2382 : :
2383 : 0 : if (!pp)
2384 : : pp = p;
2385 : 0 : seq_printf(pi, "%s%s%s%s\n",
2386 : : (kprobe_gone(p) ? "[GONE]" : ""),
2387 : 0 : ((kprobe_disabled(p) && !kprobe_gone(p)) ? "[DISABLED]" : ""),
2388 : : (kprobe_optimized(pp) ? "[OPTIMIZED]" : ""),
2389 : : (kprobe_ftrace(pp) ? "[FTRACE]" : ""));
2390 : 0 : }
2391 : :
2392 : 0 : static void *kprobe_seq_start(struct seq_file *f, loff_t *pos)
2393 : : {
2394 : 0 : return (*pos < KPROBE_TABLE_SIZE) ? pos : NULL;
2395 : : }
2396 : :
2397 : 0 : static void *kprobe_seq_next(struct seq_file *f, void *v, loff_t *pos)
2398 : : {
2399 : 0 : (*pos)++;
2400 : 0 : if (*pos >= KPROBE_TABLE_SIZE)
2401 : : return NULL;
2402 : 0 : return pos;
2403 : : }
2404 : :
2405 : 0 : static void kprobe_seq_stop(struct seq_file *f, void *v)
2406 : : {
2407 : : /* Nothing to do */
2408 : 0 : }
2409 : :
2410 : 0 : static int show_kprobe_addr(struct seq_file *pi, void *v)
2411 : : {
2412 : : struct hlist_head *head;
2413 : : struct kprobe *p, *kp;
2414 : : const char *sym = NULL;
2415 : 0 : unsigned int i = *(loff_t *) v;
2416 : 0 : unsigned long offset = 0;
2417 : : char *modname, namebuf[KSYM_NAME_LEN];
2418 : :
2419 : : head = &kprobe_table[i];
2420 : 0 : preempt_disable();
2421 : 0 : hlist_for_each_entry_rcu(p, head, hlist) {
2422 : 0 : sym = kallsyms_lookup((unsigned long)p->addr, NULL,
2423 : : &offset, &modname, namebuf);
2424 : 0 : if (kprobe_aggrprobe(p)) {
2425 : 0 : list_for_each_entry_rcu(kp, &p->list, list)
2426 : 0 : report_probe(pi, kp, sym, offset, modname, p);
2427 : : } else
2428 : 0 : report_probe(pi, p, sym, offset, modname, NULL);
2429 : : }
2430 : 0 : preempt_enable();
2431 : 0 : return 0;
2432 : : }
2433 : :
2434 : : static const struct seq_operations kprobes_seq_ops = {
2435 : : .start = kprobe_seq_start,
2436 : : .next = kprobe_seq_next,
2437 : : .stop = kprobe_seq_stop,
2438 : : .show = show_kprobe_addr
2439 : : };
2440 : :
2441 : 0 : static int kprobes_open(struct inode *inode, struct file *filp)
2442 : : {
2443 : 0 : return seq_open(filp, &kprobes_seq_ops);
2444 : : }
2445 : :
2446 : : static const struct file_operations debugfs_kprobes_operations = {
2447 : : .open = kprobes_open,
2448 : : .read = seq_read,
2449 : : .llseek = seq_lseek,
2450 : : .release = seq_release,
2451 : : };
2452 : :
2453 : : /* kprobes/blacklist -- shows which functions can not be probed */
2454 : 0 : static void *kprobe_blacklist_seq_start(struct seq_file *m, loff_t *pos)
2455 : : {
2456 : 0 : return seq_list_start(&kprobe_blacklist, *pos);
2457 : : }
2458 : :
2459 : 0 : static void *kprobe_blacklist_seq_next(struct seq_file *m, void *v, loff_t *pos)
2460 : : {
2461 : 0 : return seq_list_next(v, &kprobe_blacklist, pos);
2462 : : }
2463 : :
2464 : 0 : static int kprobe_blacklist_seq_show(struct seq_file *m, void *v)
2465 : : {
2466 : : struct kprobe_blacklist_entry *ent =
2467 : : list_entry(v, struct kprobe_blacklist_entry, list);
2468 : :
2469 : : /*
2470 : : * If /proc/kallsyms is not showing kernel address, we won't
2471 : : * show them here either.
2472 : : */
2473 : 0 : if (!kallsyms_show_value(m->file->f_cred))
2474 : 0 : seq_printf(m, "0x%px-0x%px\t%ps\n", NULL, NULL,
2475 : 0 : (void *)ent->start_addr);
2476 : : else
2477 : 0 : seq_printf(m, "0x%px-0x%px\t%ps\n", (void *)ent->start_addr,
2478 : 0 : (void *)ent->end_addr, (void *)ent->start_addr);
2479 : 0 : return 0;
2480 : : }
2481 : :
2482 : : static const struct seq_operations kprobe_blacklist_seq_ops = {
2483 : : .start = kprobe_blacklist_seq_start,
2484 : : .next = kprobe_blacklist_seq_next,
2485 : : .stop = kprobe_seq_stop, /* Reuse void function */
2486 : : .show = kprobe_blacklist_seq_show,
2487 : : };
2488 : :
2489 : 0 : static int kprobe_blacklist_open(struct inode *inode, struct file *filp)
2490 : : {
2491 : 0 : return seq_open(filp, &kprobe_blacklist_seq_ops);
2492 : : }
2493 : :
2494 : : static const struct file_operations debugfs_kprobe_blacklist_ops = {
2495 : : .open = kprobe_blacklist_open,
2496 : : .read = seq_read,
2497 : : .llseek = seq_lseek,
2498 : : .release = seq_release,
2499 : : };
2500 : :
2501 : 0 : static int arm_all_kprobes(void)
2502 : : {
2503 : : struct hlist_head *head;
2504 : : struct kprobe *p;
2505 : : unsigned int i, total = 0, errors = 0;
2506 : : int err, ret = 0;
2507 : :
2508 : 0 : mutex_lock(&kprobe_mutex);
2509 : :
2510 : : /* If kprobes are armed, just return */
2511 : 0 : if (!kprobes_all_disarmed)
2512 : : goto already_enabled;
2513 : :
2514 : : /*
2515 : : * optimize_kprobe() called by arm_kprobe() checks
2516 : : * kprobes_all_disarmed, so set kprobes_all_disarmed before
2517 : : * arm_kprobe.
2518 : : */
2519 : 0 : kprobes_all_disarmed = false;
2520 : : /* Arming kprobes doesn't optimize kprobe itself */
2521 : 0 : for (i = 0; i < KPROBE_TABLE_SIZE; i++) {
2522 : : head = &kprobe_table[i];
2523 : : /* Arm all kprobes on a best-effort basis */
2524 : 0 : hlist_for_each_entry_rcu(p, head, hlist) {
2525 : 0 : if (!kprobe_disabled(p)) {
2526 : 0 : err = arm_kprobe(p);
2527 : 0 : if (err) {
2528 : 0 : errors++;
2529 : : ret = err;
2530 : : }
2531 : 0 : total++;
2532 : : }
2533 : : }
2534 : : }
2535 : :
2536 : 0 : if (errors)
2537 : 0 : pr_warn("Kprobes globally enabled, but failed to arm %d out of %d probes\n",
2538 : : errors, total);
2539 : : else
2540 : 0 : pr_info("Kprobes globally enabled\n");
2541 : :
2542 : : already_enabled:
2543 : 0 : mutex_unlock(&kprobe_mutex);
2544 : 0 : return ret;
2545 : : }
2546 : :
2547 : 0 : static int disarm_all_kprobes(void)
2548 : : {
2549 : : struct hlist_head *head;
2550 : : struct kprobe *p;
2551 : : unsigned int i, total = 0, errors = 0;
2552 : : int err, ret = 0;
2553 : :
2554 : 0 : mutex_lock(&kprobe_mutex);
2555 : :
2556 : : /* If kprobes are already disarmed, just return */
2557 : 0 : if (kprobes_all_disarmed) {
2558 : 0 : mutex_unlock(&kprobe_mutex);
2559 : 0 : return 0;
2560 : : }
2561 : :
2562 : 0 : kprobes_all_disarmed = true;
2563 : :
2564 : 0 : for (i = 0; i < KPROBE_TABLE_SIZE; i++) {
2565 : : head = &kprobe_table[i];
2566 : : /* Disarm all kprobes on a best-effort basis */
2567 : 0 : hlist_for_each_entry_rcu(p, head, hlist) {
2568 : 0 : if (!arch_trampoline_kprobe(p) && !kprobe_disabled(p)) {
2569 : 0 : err = disarm_kprobe(p, false);
2570 : 0 : if (err) {
2571 : 0 : errors++;
2572 : : ret = err;
2573 : : }
2574 : 0 : total++;
2575 : : }
2576 : : }
2577 : : }
2578 : :
2579 : 0 : if (errors)
2580 : 0 : pr_warn("Kprobes globally disabled, but failed to disarm %d out of %d probes\n",
2581 : : errors, total);
2582 : : else
2583 : 0 : pr_info("Kprobes globally disabled\n");
2584 : :
2585 : 0 : mutex_unlock(&kprobe_mutex);
2586 : :
2587 : : /* Wait for disarming all kprobes by optimizer */
2588 : 0 : wait_for_kprobe_optimizer();
2589 : :
2590 : 0 : return ret;
2591 : : }
2592 : :
2593 : : /*
2594 : : * XXX: The debugfs bool file interface doesn't allow for callbacks
2595 : : * when the bool state is switched. We can reuse that facility when
2596 : : * available
2597 : : */
2598 : 0 : static ssize_t read_enabled_file_bool(struct file *file,
2599 : : char __user *user_buf, size_t count, loff_t *ppos)
2600 : : {
2601 : : char buf[3];
2602 : :
2603 : 0 : if (!kprobes_all_disarmed)
2604 : 0 : buf[0] = '1';
2605 : : else
2606 : 0 : buf[0] = '0';
2607 : 0 : buf[1] = '\n';
2608 : 0 : buf[2] = 0x00;
2609 : 0 : return simple_read_from_buffer(user_buf, count, ppos, buf, 2);
2610 : : }
2611 : :
2612 : 0 : static ssize_t write_enabled_file_bool(struct file *file,
2613 : : const char __user *user_buf, size_t count, loff_t *ppos)
2614 : : {
2615 : : char buf[32];
2616 : : size_t buf_size;
2617 : : int ret = 0;
2618 : :
2619 : 0 : buf_size = min(count, (sizeof(buf)-1));
2620 : 0 : if (copy_from_user(buf, user_buf, buf_size))
2621 : : return -EFAULT;
2622 : :
2623 : 0 : buf[buf_size] = '\0';
2624 : 0 : switch (buf[0]) {
2625 : : case 'y':
2626 : : case 'Y':
2627 : : case '1':
2628 : 0 : ret = arm_all_kprobes();
2629 : 0 : break;
2630 : : case 'n':
2631 : : case 'N':
2632 : : case '0':
2633 : 0 : ret = disarm_all_kprobes();
2634 : 0 : break;
2635 : : default:
2636 : : return -EINVAL;
2637 : : }
2638 : :
2639 : 0 : if (ret)
2640 : : return ret;
2641 : :
2642 : 0 : return count;
2643 : : }
2644 : :
2645 : : static const struct file_operations fops_kp = {
2646 : : .read = read_enabled_file_bool,
2647 : : .write = write_enabled_file_bool,
2648 : : .llseek = default_llseek,
2649 : : };
2650 : :
2651 : 3 : static int __init debugfs_kprobe_init(void)
2652 : : {
2653 : : struct dentry *dir;
2654 : 3 : unsigned int value = 1;
2655 : :
2656 : 3 : dir = debugfs_create_dir("kprobes", NULL);
2657 : :
2658 : 3 : debugfs_create_file("list", 0400, dir, NULL,
2659 : : &debugfs_kprobes_operations);
2660 : :
2661 : 3 : debugfs_create_file("enabled", 0600, dir, &value, &fops_kp);
2662 : :
2663 : 3 : debugfs_create_file("blacklist", 0400, dir, NULL,
2664 : : &debugfs_kprobe_blacklist_ops);
2665 : :
2666 : 3 : return 0;
2667 : : }
2668 : :
2669 : : late_initcall(debugfs_kprobe_init);
2670 : : #endif /* CONFIG_DEBUG_FS */
|
