#include <ath/kprobes.h>
35#include <ath/hash.h>
36#include <ath/init.h>
37#include <ath/slab.h>
44#include <ath/graves.h>
45#include <ath/sysctl.h>
46#include <ath/kdebug.h>
47#include <ath/memory.h>
48#include <ath/ftrace.h>
49#include <ath/cpu.h>
50#include <ath/jump_label.h>
51
52#include <asm-generic/sections.h>
53#include <asm/cacheflush.h>
54#include <asm/errno.h>
55#include <asm/uaccess.h>
56
57#define KPROBE_HASH_BITS 6
58#define KPROBE_TABLE_SIZE (1 << KPROBE_HASH_BITS)
59
60
61/*
62 * Some oddball architectures like 64bit powerpc have function descriptors
63 * so this must be overridable.
64 */
65#ifndef kprobe_lookup_name
66#define kprobe_lookup_name(name, addr) \
67 addr = ((kprobe_opcode_t *)(kallsyms_lookup_name(name)))
68#endif
69
70static int kprobes_initialized;
71static struct hlist_head kprobe_table[KPROBE_TABLE_SIZE];
72static struct hlist_head kretprobe_inst_table[KPROBE_TABLE_SIZE];
73
74/* NOTE: change this value only with kprobe_mutex held */
75static bool kprobes_all_disarmed;
76
77/* This protects kprobe_table and optimizing_list */
78static DEFINE_MUTEX(kprobe_mutex);
79static DEFINE_PER_CPU(struct kprobe *, kprobe_instance) = NULL;
80static struct {
81 raw_spinlock_t lock ____cacheline_aligned_in_smp;
82} kretprobe_table_locks[KPROBE_TABLE_SIZE];
83
84static raw_spinlock_t *kretprobe_table_lock_ptr(unsigned long hash)
85{
86 return &(kretprobe_table_locks[hash].lock);
87}
88
89/*
90 * Normally, functions that we'd want to prohibit kprobes in, are marked
91 * __kprobes. But, there are cases where such functions already belong to
92 * a different section (__sched for preempt_schedule)
93 *
94 * For such cases, we now have a blacklist
95 */
96static struct kprobe_blackpoint kprobe_blacklist[] = {
97 {"preempt_schedule",},
98 {"native_get_debugreg",},
99 {"irq_entries_start",},
100 {"common_interrupt",},
101 {"mcount",}, /* mcount can be called from everywhere */
102 {NULL} /* Terminator */
103};
104
105#ifdef __ARCH_WANT_KPROBES_INSN_SLOT
106/*
107 * kprobe->ainsn.insn points to the copy of the instruction to be
108 * single-stepped. x86_64, POWER4 and above have no-exec support and
109 * stepping on the instruction on a vmalloced/kmalloced/data page
110 * is a recipe for disaster
111 */
112struct kprobe_insn_page {
113 struct list_head list;
114 kprobe_opcode_t *insns; /* Page of instruction slots */
115 int nused;
116 int ngarbage;
117 char slot_used[];
118};
119
120#define KPROBE_INSN_PAGE_SIZE(slots) \
121 (offsetof(struct kprobe_insn_page, slot_used) + \
122 (sizeof(char) * (slots)))
123
124struct kprobe_insn_cache {
125 struct list_head pages; /* list of kprobe_insn_page */
126 size_t insn_size; /* size of instruction slot */
127 int nr_garbage;
128};
129
130static int slots_per_page(struct kprobe_insn_cache *c)
131{
132 return PAGE_SIZE/(c->insn_size * sizeof(kprobe_opcode_t));
133}
134
135enum kprobe_slot_state {
136 SLOT_CLEAN = 0,
137 SLOT_DIRTY = 1,
138 SLOT_USED = 2,
139};
140
141static DEFINE_MUTEX(kprobe_insn_mutex); /* Protects kprobe_insn_slots */
142static struct kprobe_insn_cache kprobe_insn_slots = {
143 .pages = LIST_HEAD_INIT(kprobe_insn_slots.pages),
144 .insn_size = MAX_INSN_SIZE,
145 .nr_garbage = 0,
146};
147static int __kprobes collect_garbage_slots(struct kprobe_insn_cache *c);
148
149/**
150 * __get_insn_slot() - Find a slot on an executable page for an instruction.
151 * We allocate an executable page if there's no room on existing ones.
152 */
153static kprobe_opcode_t __kprobes *__get_insn_slot(struct kprobe_insn_cache *c)
154{
155 struct kprobe_insn_page *kip;
156
157 retry:
158 list_for_each_entry(kip, &c->pages, list) {
159 if (kip->nused < slots_per_page(c)) {
160 int i;
161 for (i = 0; i < slots_per_page(c); i++) {
162 if (kip->slot_used[i] == SLOT_CLEAN) {
163 kip->slot_used[i] = SLOT_USED;
164 kip->nused++;
165 return kip->insns + (i * c->insn_size);
166 }
167 }
168 /* kip->nused is broken. Fix it. */
169 kip->nused = slots_per_page(c);
170 WARN_ON(1);
171 }
172 }
173
174 /* If there are any garbage slots, collect it and try again. */
175 if (c->nr_garbage && collect_garbage_slots(c) == 0)
176 goto retry;
177
178 /* All out of space. Need to allocate a new page. */
179 kip = kmalloc(KPROBE_INSN_PAGE_SIZE(slots_per_page(c)), GFP_KERNEL);
180 if (!kip)
181 return NULL;
182
183 /*
184 * Use module_alloc so this page is within +/- 2GB of where the
185 * kernel image and loaded module images reside. This is required
186 * so x86_64 can correctly handle the %rip-relative fixups.
187 */
188 kip->insns = module_alloc(PAGE_SIZE);
189 if (!kip->insns) {
190 kfree(kip);
191 return NULL;
192 }
193 INIT_LIST_HEAD(&kip->list);
194 memset(kip->slot_used, SLOT_CLEAN, slots_per_page(c));
195 kip->slot_used[0] = SLOT_USED;
196 kip->nused = 1;
197 kip->ngarbage = 0;
198 list_add(&kip->list, &c->pages);
199 return kip->insns;
200}
201