Blame view
kernel/kcov.c
27.7 KB
b24413180 License cleanup: ... |
1 |
// SPDX-License-Identifier: GPL-2.0 |
5c9a8750a kernel: add kcov ... |
2 |
#define pr_fmt(fmt) "kcov: " fmt |
36f05ae8b kcov: don't profi... |
3 |
#define DISABLE_BRANCH_PROFILING |
db862358a kcov: add more mi... |
4 |
#include <linux/atomic.h> |
5c9a8750a kernel: add kcov ... |
5 |
#include <linux/compiler.h> |
db862358a kcov: add more mi... |
6 7 |
#include <linux/errno.h> #include <linux/export.h> |
5c9a8750a kernel: add kcov ... |
8 9 10 |
#include <linux/types.h> #include <linux/file.h> #include <linux/fs.h> |
eec028c93 kcov: remote cove... |
11 |
#include <linux/hashtable.h> |
db862358a kcov: add more mi... |
12 |
#include <linux/init.h> |
5c9a8750a kernel: add kcov ... |
13 |
#include <linux/mm.h> |
db862358a kcov: add more mi... |
14 |
#include <linux/preempt.h> |
5c9a8750a kernel: add kcov ... |
15 |
#include <linux/printk.h> |
166ad0e1e kcov: add missing... |
16 |
#include <linux/sched.h> |
5c9a8750a kernel: add kcov ... |
17 18 19 20 21 22 |
#include <linux/slab.h> #include <linux/spinlock.h> #include <linux/vmalloc.h> #include <linux/debugfs.h> #include <linux/uaccess.h> #include <linux/kcov.h> |
39e07cb60 kcov: convert kco... |
23 |
#include <linux/refcount.h> |
eec028c93 kcov: remote cove... |
24 |
#include <linux/log2.h> |
4983f0ab7 kcov: make kcov w... |
25 |
#include <asm/setup.h> |
5c9a8750a kernel: add kcov ... |
26 |
|
eec028c93 kcov: remote cove... |
27 |
#define kcov_debug(fmt, ...) pr_debug("%s: " fmt, __func__, ##__VA_ARGS__) |
ded97d2c2 kcov: support com... |
28 29 |
/* Number of 64-bit words written per one comparison: */ #define KCOV_WORDS_PER_CMP 4 |
5c9a8750a kernel: add kcov ... |
30 31 32 33 34 35 |
/* * kcov descriptor (one per opened debugfs file). * State transitions of the descriptor: * - initial state after open() * - then there must be a single ioctl(KCOV_INIT_TRACE) call * - then, mmap() call (several calls are allowed but not useful) |
ded97d2c2 kcov: support com... |
36 37 38 39 40 41 |
* - then, ioctl(KCOV_ENABLE, arg), where arg is * KCOV_TRACE_PC - to trace only the PCs * or * KCOV_TRACE_CMP - to trace only the comparison operands * - then, ioctl(KCOV_DISABLE) to disable the task. * Enabling/disabling ioctls can be repeated (only one task a time allowed). |
5c9a8750a kernel: add kcov ... |
42 43 44 45 46 47 |
*/ struct kcov { /* * Reference counter. We keep one for: * - opened file descriptor * - task with enabled coverage (we can't unwire it from another task) |
eec028c93 kcov: remote cove... |
48 |
* - each code section for remote coverage collection |
5c9a8750a kernel: add kcov ... |
49 |
*/ |
39e07cb60 kcov: convert kco... |
50 |
refcount_t refcount; |
5c9a8750a kernel: add kcov ... |
51 52 53 |
/* The lock protects mode, size, area and t. */ spinlock_t lock; enum kcov_mode mode; |
eec028c93 kcov: remote cove... |
54 55 |
/* Size of arena (in long's). */ unsigned int size; |
5c9a8750a kernel: add kcov ... |
56 57 58 59 |
/* Coverage buffer shared with user space. */ void *area; /* Task for which we collect coverage, or NULL. */ struct task_struct *t; |
eec028c93 kcov: remote cove... |
60 61 62 63 64 65 66 67 68 |
/* Collecting coverage from remote (background) threads. */ bool remote; /* Size of remote area (in long's). */ unsigned int remote_size; /* * Sequence is incremented each time kcov is reenabled, used by * kcov_remote_stop(), see the comment there. */ int sequence; |
5c9a8750a kernel: add kcov ... |
69 |
}; |
eec028c93 kcov: remote cove... |
70 71 72 73 74 75 76 77 78 79 80 81 82 83 |
struct kcov_remote_area { struct list_head list; unsigned int size; }; struct kcov_remote { u64 handle; struct kcov *kcov; struct hlist_node hnode; }; static DEFINE_SPINLOCK(kcov_remote_lock); static DEFINE_HASHTABLE(kcov_remote_map, 4); static struct list_head kcov_remote_areas = LIST_HEAD_INIT(kcov_remote_areas); |
5ff3b30ab kcov: collect cov... |
84 85 86 87 88 89 90 91 92 |
struct kcov_percpu_data { void *irq_area; unsigned int saved_mode; unsigned int saved_size; void *saved_area; struct kcov *saved_kcov; int saved_sequence; }; |
fed79d057 kcov: make some s... |
93 |
static DEFINE_PER_CPU(struct kcov_percpu_data, kcov_percpu_data); |
5ff3b30ab kcov: collect cov... |
94 |
|
eec028c93 kcov: remote cove... |
95 96 97 98 99 100 101 102 103 104 105 |
/* Must be called with kcov_remote_lock locked. */ static struct kcov_remote *kcov_remote_find(u64 handle) { struct kcov_remote *remote; hash_for_each_possible(kcov_remote_map, remote, hnode, handle) { if (remote->handle == handle) return remote; } return NULL; } |
3c61df388 kcov: cleanup deb... |
106 |
/* Must be called with kcov_remote_lock locked. */ |
eec028c93 kcov: remote cove... |
107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 |
static struct kcov_remote *kcov_remote_add(struct kcov *kcov, u64 handle) { struct kcov_remote *remote; if (kcov_remote_find(handle)) return ERR_PTR(-EEXIST); remote = kmalloc(sizeof(*remote), GFP_ATOMIC); if (!remote) return ERR_PTR(-ENOMEM); remote->handle = handle; remote->kcov = kcov; hash_add(kcov_remote_map, &remote->hnode, handle); return remote; } /* Must be called with kcov_remote_lock locked. */ static struct kcov_remote_area *kcov_remote_area_get(unsigned int size) { struct kcov_remote_area *area; struct list_head *pos; |
eec028c93 kcov: remote cove... |
127 128 129 130 |
list_for_each(pos, &kcov_remote_areas) { area = list_entry(pos, struct kcov_remote_area, list); if (area->size == size) { list_del(&area->list); |
eec028c93 kcov: remote cove... |
131 132 133 |
return area; } } |
eec028c93 kcov: remote cove... |
134 135 136 137 138 139 140 |
return NULL; } /* Must be called with kcov_remote_lock locked. */ static void kcov_remote_area_put(struct kcov_remote_area *area, unsigned int size) { |
eec028c93 kcov: remote cove... |
141 142 143 144 |
INIT_LIST_HEAD(&area->list); area->size = size; list_add(&area->list, &kcov_remote_areas); } |
903e8ff86 kernel/kcov.c: ma... |
145 |
static notrace bool check_kcov_mode(enum kcov_mode needed_mode, struct task_struct *t) |
5c9a8750a kernel: add kcov ... |
146 |
{ |
0ed557aa8 sched/core / kcov... |
147 |
unsigned int mode; |
5c9a8750a kernel: add kcov ... |
148 |
|
5c9a8750a kernel: add kcov ... |
149 150 |
/* * We are interested in code coverage as a function of a syscall inputs, |
5ff3b30ab kcov: collect cov... |
151 152 |
* so we ignore code executed in interrupts, unless we are in a remote * coverage collection section in a softirq. |
5c9a8750a kernel: add kcov ... |
153 |
*/ |
5ff3b30ab kcov: collect cov... |
154 |
if (!in_task() && !(in_serving_softirq() && t->kcov_softirq)) |
ded97d2c2 kcov: support com... |
155 |
return false; |
5c9a8750a kernel: add kcov ... |
156 |
mode = READ_ONCE(t->kcov_mode); |
ded97d2c2 kcov: support com... |
157 158 159 160 161 |
/* * There is some code that runs in interrupts but for which * in_interrupt() returns false (e.g. preempt_schedule_irq()). * READ_ONCE()/barrier() effectively provides load-acquire wrt * interrupts, there are paired barrier()/WRITE_ONCE() in |
eec028c93 kcov: remote cove... |
162 |
* kcov_start(). |
ded97d2c2 kcov: support com... |
163 164 165 166 |
*/ barrier(); return mode == needed_mode; } |
4983f0ab7 kcov: make kcov w... |
167 |
|
903e8ff86 kernel/kcov.c: ma... |
168 |
static notrace unsigned long canonicalize_ip(unsigned long ip) |
ded97d2c2 kcov: support com... |
169 |
{ |
4983f0ab7 kcov: make kcov w... |
170 |
#ifdef CONFIG_RANDOMIZE_BASE |
ded97d2c2 kcov: support com... |
171 |
ip -= kaslr_offset(); |
4983f0ab7 kcov: make kcov w... |
172 |
#endif |
ded97d2c2 kcov: support com... |
173 174 |
return ip; } |
5c9a8750a kernel: add kcov ... |
175 |
|
ded97d2c2 kcov: support com... |
176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 |
/* * Entry point from instrumented code. * This is called once per basic-block/edge. */ void notrace __sanitizer_cov_trace_pc(void) { struct task_struct *t; unsigned long *area; unsigned long ip = canonicalize_ip(_RET_IP_); unsigned long pos; t = current; if (!check_kcov_mode(KCOV_MODE_TRACE_PC, t)) return; area = t->kcov_area; /* The first 64-bit word is the number of subsequent PCs. */ pos = READ_ONCE(area[0]) + 1; if (likely(pos < t->kcov_size)) { area[pos] = ip; WRITE_ONCE(area[0], pos); |
5c9a8750a kernel: add kcov ... |
197 198 199 |
} } EXPORT_SYMBOL(__sanitizer_cov_trace_pc); |
ded97d2c2 kcov: support com... |
200 |
#ifdef CONFIG_KCOV_ENABLE_COMPARISONS |
634724431 kernel/kcov.c: ma... |
201 |
static void notrace write_comp_data(u64 type, u64 arg1, u64 arg2, u64 ip) |
ded97d2c2 kcov: support com... |
202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 |
{ struct task_struct *t; u64 *area; u64 count, start_index, end_pos, max_pos; t = current; if (!check_kcov_mode(KCOV_MODE_TRACE_CMP, t)) return; ip = canonicalize_ip(ip); /* * We write all comparison arguments and types as u64. * The buffer was allocated for t->kcov_size unsigned longs. */ area = (u64 *)t->kcov_area; max_pos = t->kcov_size * sizeof(unsigned long); count = READ_ONCE(area[0]); /* Every record is KCOV_WORDS_PER_CMP 64-bit words. */ start_index = 1 + count * KCOV_WORDS_PER_CMP; end_pos = (start_index + KCOV_WORDS_PER_CMP) * sizeof(u64); if (likely(end_pos <= max_pos)) { area[start_index] = type; area[start_index + 1] = arg1; area[start_index + 2] = arg2; area[start_index + 3] = ip; WRITE_ONCE(area[0], count + 1); } } void notrace __sanitizer_cov_trace_cmp1(u8 arg1, u8 arg2) { write_comp_data(KCOV_CMP_SIZE(0), arg1, arg2, _RET_IP_); } EXPORT_SYMBOL(__sanitizer_cov_trace_cmp1); void notrace __sanitizer_cov_trace_cmp2(u16 arg1, u16 arg2) { write_comp_data(KCOV_CMP_SIZE(1), arg1, arg2, _RET_IP_); } EXPORT_SYMBOL(__sanitizer_cov_trace_cmp2); |
689d77f00 kcov: fix compari... |
245 |
void notrace __sanitizer_cov_trace_cmp4(u32 arg1, u32 arg2) |
ded97d2c2 kcov: support com... |
246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 |
{ write_comp_data(KCOV_CMP_SIZE(2), arg1, arg2, _RET_IP_); } EXPORT_SYMBOL(__sanitizer_cov_trace_cmp4); void notrace __sanitizer_cov_trace_cmp8(u64 arg1, u64 arg2) { write_comp_data(KCOV_CMP_SIZE(3), arg1, arg2, _RET_IP_); } EXPORT_SYMBOL(__sanitizer_cov_trace_cmp8); void notrace __sanitizer_cov_trace_const_cmp1(u8 arg1, u8 arg2) { write_comp_data(KCOV_CMP_SIZE(0) | KCOV_CMP_CONST, arg1, arg2, _RET_IP_); } EXPORT_SYMBOL(__sanitizer_cov_trace_const_cmp1); void notrace __sanitizer_cov_trace_const_cmp2(u16 arg1, u16 arg2) { write_comp_data(KCOV_CMP_SIZE(1) | KCOV_CMP_CONST, arg1, arg2, _RET_IP_); } EXPORT_SYMBOL(__sanitizer_cov_trace_const_cmp2); |
689d77f00 kcov: fix compari... |
270 |
void notrace __sanitizer_cov_trace_const_cmp4(u32 arg1, u32 arg2) |
ded97d2c2 kcov: support com... |
271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 |
{ write_comp_data(KCOV_CMP_SIZE(2) | KCOV_CMP_CONST, arg1, arg2, _RET_IP_); } EXPORT_SYMBOL(__sanitizer_cov_trace_const_cmp4); void notrace __sanitizer_cov_trace_const_cmp8(u64 arg1, u64 arg2) { write_comp_data(KCOV_CMP_SIZE(3) | KCOV_CMP_CONST, arg1, arg2, _RET_IP_); } EXPORT_SYMBOL(__sanitizer_cov_trace_const_cmp8); void notrace __sanitizer_cov_trace_switch(u64 val, u64 *cases) { u64 i; u64 count = cases[0]; u64 size = cases[1]; u64 type = KCOV_CMP_CONST; switch (size) { case 8: type |= KCOV_CMP_SIZE(0); break; case 16: type |= KCOV_CMP_SIZE(1); break; case 32: type |= KCOV_CMP_SIZE(2); break; case 64: type |= KCOV_CMP_SIZE(3); break; default: return; } for (i = 0; i < count; i++) write_comp_data(type, cases[i + 2], val, _RET_IP_); } EXPORT_SYMBOL(__sanitizer_cov_trace_switch); #endif /* ifdef CONFIG_KCOV_ENABLE_COMPARISONS */ |
76484b1c7 kcov: move t->kco... |
312 313 314 |
static void kcov_start(struct task_struct *t, struct kcov *kcov, unsigned int size, void *area, enum kcov_mode mode, int sequence) |
eec028c93 kcov: remote cove... |
315 316 317 |
{ kcov_debug("t = %px, size = %u, area = %px ", t, size, area); |
76484b1c7 kcov: move t->kco... |
318 |
t->kcov = kcov; |
eec028c93 kcov: remote cove... |
319 320 321 |
/* Cache in task struct for performance. */ t->kcov_size = size; t->kcov_area = area; |
eeb91f9a2 kcov: move t->kco... |
322 |
t->kcov_sequence = sequence; |
eec028c93 kcov: remote cove... |
323 324 325 |
/* See comment in check_kcov_mode(). */ barrier(); WRITE_ONCE(t->kcov_mode, mode); |
eec028c93 kcov: remote cove... |
326 327 328 329 330 331 |
} static void kcov_stop(struct task_struct *t) { WRITE_ONCE(t->kcov_mode, KCOV_MODE_DISABLED); barrier(); |
76484b1c7 kcov: move t->kco... |
332 |
t->kcov = NULL; |
eec028c93 kcov: remote cove... |
333 334 335 336 337 338 339 |
t->kcov_size = 0; t->kcov_area = NULL; } static void kcov_task_reset(struct task_struct *t) { kcov_stop(t); |
eec028c93 kcov: remote cove... |
340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 |
t->kcov_sequence = 0; t->kcov_handle = 0; } void kcov_task_init(struct task_struct *t) { kcov_task_reset(t); t->kcov_handle = current->kcov_handle; } static void kcov_reset(struct kcov *kcov) { kcov->t = NULL; kcov->mode = KCOV_MODE_INIT; kcov->remote = false; kcov->remote_size = 0; kcov->sequence++; } static void kcov_remote_reset(struct kcov *kcov) { int bkt; struct kcov_remote *remote; struct hlist_node *tmp; |
5ff3b30ab kcov: collect cov... |
364 |
unsigned long flags; |
eec028c93 kcov: remote cove... |
365 |
|
5ff3b30ab kcov: collect cov... |
366 |
spin_lock_irqsave(&kcov_remote_lock, flags); |
eec028c93 kcov: remote cove... |
367 368 369 |
hash_for_each_safe(kcov_remote_map, bkt, tmp, remote, hnode) { if (remote->kcov != kcov) continue; |
eec028c93 kcov: remote cove... |
370 371 372 373 374 |
hash_del(&remote->hnode); kfree(remote); } /* Do reset before unlock to prevent races with kcov_remote_start(). */ kcov_reset(kcov); |
5ff3b30ab kcov: collect cov... |
375 |
spin_unlock_irqrestore(&kcov_remote_lock, flags); |
eec028c93 kcov: remote cove... |
376 377 378 379 380 381 382 383 384 385 |
} static void kcov_disable(struct task_struct *t, struct kcov *kcov) { kcov_task_reset(t); if (kcov->remote) kcov_remote_reset(kcov); else kcov_reset(kcov); } |
5c9a8750a kernel: add kcov ... |
386 387 |
static void kcov_get(struct kcov *kcov) { |
39e07cb60 kcov: convert kco... |
388 |
refcount_inc(&kcov->refcount); |
5c9a8750a kernel: add kcov ... |
389 390 391 392 |
} static void kcov_put(struct kcov *kcov) { |
39e07cb60 kcov: convert kco... |
393 |
if (refcount_dec_and_test(&kcov->refcount)) { |
eec028c93 kcov: remote cove... |
394 |
kcov_remote_reset(kcov); |
5c9a8750a kernel: add kcov ... |
395 396 397 398 |
vfree(kcov->area); kfree(kcov); } } |
5c9a8750a kernel: add kcov ... |
399 400 401 |
void kcov_task_exit(struct task_struct *t) { struct kcov *kcov; |
5ff3b30ab kcov: collect cov... |
402 |
unsigned long flags; |
5c9a8750a kernel: add kcov ... |
403 404 405 406 |
kcov = t->kcov; if (kcov == NULL) return; |
eec028c93 kcov: remote cove... |
407 |
|
5ff3b30ab kcov: collect cov... |
408 |
spin_lock_irqsave(&kcov->lock, flags); |
eec028c93 kcov: remote cove... |
409 410 411 412 413 414 415 416 |
kcov_debug("t = %px, kcov->t = %px ", t, kcov->t); /* * For KCOV_ENABLE devices we want to make sure that t->kcov->t == t, * which comes down to: * WARN_ON(!kcov->remote && kcov->t != t); * * For KCOV_REMOTE_ENABLE devices, the exiting task is either: |
3021e6921 kcov: check kcov_... |
417 418 |
* * 1. A remote task between kcov_remote_start() and kcov_remote_stop(). |
eec028c93 kcov: remote cove... |
419 420 421 422 423 424 425 426 427 |
* In this case we should print a warning right away, since a task * shouldn't be exiting when it's in a kcov coverage collection * section. Here t points to the task that is collecting remote * coverage, and t->kcov->t points to the thread that created the * kcov device. Which means that to detect this case we need to * check that t != t->kcov->t, and this gives us the following: * WARN_ON(kcov->remote && kcov->t != t); * * 2. The task that created kcov exiting without calling KCOV_DISABLE, |
3021e6921 kcov: check kcov_... |
428 |
* and then again we make sure that t->kcov->t == t: |
eec028c93 kcov: remote cove... |
429 430 431 432 |
* WARN_ON(kcov->remote && kcov->t != t); * * By combining all three checks into one we get: */ |
5c9a8750a kernel: add kcov ... |
433 |
if (WARN_ON(kcov->t != t)) { |
5ff3b30ab kcov: collect cov... |
434 |
spin_unlock_irqrestore(&kcov->lock, flags); |
5c9a8750a kernel: add kcov ... |
435 436 437 |
return; } /* Just to not leave dangling references behind. */ |
eec028c93 kcov: remote cove... |
438 |
kcov_disable(t, kcov); |
5ff3b30ab kcov: collect cov... |
439 |
spin_unlock_irqrestore(&kcov->lock, flags); |
5c9a8750a kernel: add kcov ... |
440 441 442 443 444 445 446 447 448 449 |
kcov_put(kcov); } static int kcov_mmap(struct file *filep, struct vm_area_struct *vma) { int res = 0; void *area; struct kcov *kcov = vma->vm_file->private_data; unsigned long size, off; struct page *page; |
5ff3b30ab kcov: collect cov... |
450 |
unsigned long flags; |
5c9a8750a kernel: add kcov ... |
451 452 453 454 |
area = vmalloc_user(vma->vm_end - vma->vm_start); if (!area) return -ENOMEM; |
5ff3b30ab kcov: collect cov... |
455 |
spin_lock_irqsave(&kcov->lock, flags); |
5c9a8750a kernel: add kcov ... |
456 |
size = kcov->size * sizeof(unsigned long); |
ded97d2c2 kcov: support com... |
457 |
if (kcov->mode != KCOV_MODE_INIT || vma->vm_pgoff != 0 || |
5c9a8750a kernel: add kcov ... |
458 459 460 461 462 463 464 |
vma->vm_end - vma->vm_start != size) { res = -EINVAL; goto exit; } if (!kcov->area) { kcov->area = area; vma->vm_flags |= VM_DONTEXPAND; |
5ff3b30ab kcov: collect cov... |
465 |
spin_unlock_irqrestore(&kcov->lock, flags); |
5c9a8750a kernel: add kcov ... |
466 467 468 469 470 471 472 473 |
for (off = 0; off < size; off += PAGE_SIZE) { page = vmalloc_to_page(kcov->area + off); if (vm_insert_page(vma, vma->vm_start + off, page)) WARN_ONCE(1, "vm_insert_page() failed"); } return 0; } exit: |
5ff3b30ab kcov: collect cov... |
474 |
spin_unlock_irqrestore(&kcov->lock, flags); |
5c9a8750a kernel: add kcov ... |
475 476 477 478 479 480 481 482 483 484 485 |
vfree(area); return res; } static int kcov_open(struct inode *inode, struct file *filep) { struct kcov *kcov; kcov = kzalloc(sizeof(*kcov), GFP_KERNEL); if (!kcov) return -ENOMEM; |
ded97d2c2 kcov: support com... |
486 |
kcov->mode = KCOV_MODE_DISABLED; |
eec028c93 kcov: remote cove... |
487 |
kcov->sequence = 1; |
39e07cb60 kcov: convert kco... |
488 |
refcount_set(&kcov->refcount, 1); |
5c9a8750a kernel: add kcov ... |
489 490 491 492 493 494 495 496 497 498 |
spin_lock_init(&kcov->lock); filep->private_data = kcov; return nonseekable_open(inode, filep); } static int kcov_close(struct inode *inode, struct file *filep) { kcov_put(filep->private_data); return 0; } |
eec028c93 kcov: remote cove... |
499 500 501 502 503 504 505 506 507 508 509 510 511 |
static int kcov_get_mode(unsigned long arg) { if (arg == KCOV_TRACE_PC) return KCOV_MODE_TRACE_PC; else if (arg == KCOV_TRACE_CMP) #ifdef CONFIG_KCOV_ENABLE_COMPARISONS return KCOV_MODE_TRACE_CMP; #else return -ENOTSUPP; #endif else return -EINVAL; } |
dc55daff9 kcov: prefault th... |
512 513 514 515 516 517 518 519 520 521 522 523 524 525 |
/* * Fault in a lazily-faulted vmalloc area before it can be used by * __santizer_cov_trace_pc(), to avoid recursion issues if any code on the * vmalloc fault handling path is instrumented. */ static void kcov_fault_in_area(struct kcov *kcov) { unsigned long stride = PAGE_SIZE / sizeof(unsigned long); unsigned long *area = kcov->area; unsigned long offset; for (offset = 0; offset < kcov->size; offset += stride) READ_ONCE(area[offset]); } |
eec028c93 kcov: remote cove... |
526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 |
static inline bool kcov_check_handle(u64 handle, bool common_valid, bool uncommon_valid, bool zero_valid) { if (handle & ~(KCOV_SUBSYSTEM_MASK | KCOV_INSTANCE_MASK)) return false; switch (handle & KCOV_SUBSYSTEM_MASK) { case KCOV_SUBSYSTEM_COMMON: return (handle & KCOV_INSTANCE_MASK) ? common_valid : zero_valid; case KCOV_SUBSYSTEM_USB: return uncommon_valid; default: return false; } return false; } |
5c9a8750a kernel: add kcov ... |
542 543 544 545 546 |
static int kcov_ioctl_locked(struct kcov *kcov, unsigned int cmd, unsigned long arg) { struct task_struct *t; unsigned long size, unused; |
eec028c93 kcov: remote cove... |
547 548 549 |
int mode, i; struct kcov_remote_arg *remote_arg; struct kcov_remote *remote; |
5ff3b30ab kcov: collect cov... |
550 |
unsigned long flags; |
5c9a8750a kernel: add kcov ... |
551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 |
switch (cmd) { case KCOV_INIT_TRACE: /* * Enable kcov in trace mode and setup buffer size. * Must happen before anything else. */ if (kcov->mode != KCOV_MODE_DISABLED) return -EBUSY; /* * Size must be at least 2 to hold current position and one PC. * Later we allocate size * sizeof(unsigned long) memory, * that must not overflow. */ size = arg; if (size < 2 || size > INT_MAX / sizeof(unsigned long)) return -EINVAL; kcov->size = size; |
ded97d2c2 kcov: support com... |
569 |
kcov->mode = KCOV_MODE_INIT; |
5c9a8750a kernel: add kcov ... |
570 571 572 573 574 575 576 577 578 |
return 0; case KCOV_ENABLE: /* * Enable coverage for the current task. * At this point user must have been enabled trace mode, * and mmapped the file. Coverage collection is disabled only * at task exit or voluntary by KCOV_DISABLE. After that it can * be enabled for another task. */ |
ded97d2c2 kcov: support com... |
579 |
if (kcov->mode != KCOV_MODE_INIT || !kcov->area) |
5c9a8750a kernel: add kcov ... |
580 |
return -EINVAL; |
a77660d23 kcov: detect doub... |
581 582 |
t = current; if (kcov->t != NULL || t->kcov != NULL) |
5c9a8750a kernel: add kcov ... |
583 |
return -EBUSY; |
eec028c93 kcov: remote cove... |
584 585 586 |
mode = kcov_get_mode(arg); if (mode < 0) return mode; |
dc55daff9 kcov: prefault th... |
587 |
kcov_fault_in_area(kcov); |
eec028c93 kcov: remote cove... |
588 |
kcov->mode = mode; |
76484b1c7 kcov: move t->kco... |
589 |
kcov_start(t, kcov, kcov->size, kcov->area, kcov->mode, |
eec028c93 kcov: remote cove... |
590 |
kcov->sequence); |
5c9a8750a kernel: add kcov ... |
591 |
kcov->t = t; |
eec028c93 kcov: remote cove... |
592 |
/* Put either in kcov_task_exit() or in KCOV_DISABLE. */ |
5c9a8750a kernel: add kcov ... |
593 594 595 596 597 598 599 600 601 602 |
kcov_get(kcov); return 0; case KCOV_DISABLE: /* Disable coverage for the current task. */ unused = arg; if (unused != 0 || current->kcov != kcov) return -EINVAL; t = current; if (WARN_ON(kcov->t != t)) return -EINVAL; |
eec028c93 kcov: remote cove... |
603 |
kcov_disable(t, kcov); |
5c9a8750a kernel: add kcov ... |
604 605 |
kcov_put(kcov); return 0; |
eec028c93 kcov: remote cove... |
606 |
case KCOV_REMOTE_ENABLE: |
eec028c93 kcov: remote cove... |
607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 622 |
if (kcov->mode != KCOV_MODE_INIT || !kcov->area) return -EINVAL; t = current; if (kcov->t != NULL || t->kcov != NULL) return -EBUSY; remote_arg = (struct kcov_remote_arg *)arg; mode = kcov_get_mode(remote_arg->trace_mode); if (mode < 0) return mode; if (remote_arg->area_size > LONG_MAX / sizeof(unsigned long)) return -EINVAL; kcov->mode = mode; t->kcov = kcov; kcov->t = t; kcov->remote = true; kcov->remote_size = remote_arg->area_size; |
5ff3b30ab kcov: collect cov... |
623 |
spin_lock_irqsave(&kcov_remote_lock, flags); |
eec028c93 kcov: remote cove... |
624 |
for (i = 0; i < remote_arg->num_handles; i++) { |
eec028c93 kcov: remote cove... |
625 626 |
if (!kcov_check_handle(remote_arg->handles[i], false, true, false)) { |
5ff3b30ab kcov: collect cov... |
627 628 |
spin_unlock_irqrestore(&kcov_remote_lock, flags); |
eec028c93 kcov: remote cove... |
629 630 631 632 633 |
kcov_disable(t, kcov); return -EINVAL; } remote = kcov_remote_add(kcov, remote_arg->handles[i]); if (IS_ERR(remote)) { |
5ff3b30ab kcov: collect cov... |
634 635 |
spin_unlock_irqrestore(&kcov_remote_lock, flags); |
eec028c93 kcov: remote cove... |
636 637 638 639 640 |
kcov_disable(t, kcov); return PTR_ERR(remote); } } if (remote_arg->common_handle) { |
eec028c93 kcov: remote cove... |
641 642 |
if (!kcov_check_handle(remote_arg->common_handle, true, false, false)) { |
5ff3b30ab kcov: collect cov... |
643 644 |
spin_unlock_irqrestore(&kcov_remote_lock, flags); |
eec028c93 kcov: remote cove... |
645 646 647 648 649 650 |
kcov_disable(t, kcov); return -EINVAL; } remote = kcov_remote_add(kcov, remote_arg->common_handle); if (IS_ERR(remote)) { |
5ff3b30ab kcov: collect cov... |
651 652 |
spin_unlock_irqrestore(&kcov_remote_lock, flags); |
eec028c93 kcov: remote cove... |
653 654 655 656 657 |
kcov_disable(t, kcov); return PTR_ERR(remote); } t->kcov_handle = remote_arg->common_handle; } |
5ff3b30ab kcov: collect cov... |
658 |
spin_unlock_irqrestore(&kcov_remote_lock, flags); |
eec028c93 kcov: remote cove... |
659 660 661 |
/* Put either in kcov_task_exit() or in KCOV_DISABLE. */ kcov_get(kcov); return 0; |
5c9a8750a kernel: add kcov ... |
662 663 664 665 666 667 668 669 670 |
default: return -ENOTTY; } } static long kcov_ioctl(struct file *filep, unsigned int cmd, unsigned long arg) { struct kcov *kcov; int res; |
eec028c93 kcov: remote cove... |
671 672 673 |
struct kcov_remote_arg *remote_arg = NULL; unsigned int remote_num_handles; unsigned long remote_arg_size; |
5ff3b30ab kcov: collect cov... |
674 |
unsigned long flags; |
eec028c93 kcov: remote cove... |
675 676 677 678 679 680 681 682 683 684 685 686 687 688 689 690 691 692 |
if (cmd == KCOV_REMOTE_ENABLE) { if (get_user(remote_num_handles, (unsigned __user *)(arg + offsetof(struct kcov_remote_arg, num_handles)))) return -EFAULT; if (remote_num_handles > KCOV_REMOTE_MAX_HANDLES) return -EINVAL; remote_arg_size = struct_size(remote_arg, handles, remote_num_handles); remote_arg = memdup_user((void __user *)arg, remote_arg_size); if (IS_ERR(remote_arg)) return PTR_ERR(remote_arg); if (remote_arg->num_handles != remote_num_handles) { kfree(remote_arg); return -EINVAL; } arg = (unsigned long)remote_arg; } |
5c9a8750a kernel: add kcov ... |
693 694 |
kcov = filep->private_data; |
5ff3b30ab kcov: collect cov... |
695 |
spin_lock_irqsave(&kcov->lock, flags); |
5c9a8750a kernel: add kcov ... |
696 |
res = kcov_ioctl_locked(kcov, cmd, arg); |
5ff3b30ab kcov: collect cov... |
697 |
spin_unlock_irqrestore(&kcov->lock, flags); |
eec028c93 kcov: remote cove... |
698 699 |
kfree(remote_arg); |
5c9a8750a kernel: add kcov ... |
700 701 702 703 704 705 |
return res; } static const struct file_operations kcov_fops = { .open = kcov_open, .unlocked_ioctl = kcov_ioctl, |
7483e5d42 kcov: support com... |
706 |
.compat_ioctl = kcov_ioctl, |
5c9a8750a kernel: add kcov ... |
707 708 709 |
.mmap = kcov_mmap, .release = kcov_close, }; |
eec028c93 kcov: remote cove... |
710 711 |
/* * kcov_remote_start() and kcov_remote_stop() can be used to annotate a section |
5ff3b30ab kcov: collect cov... |
712 713 |
* of code in a kernel background thread or in a softirq to allow kcov to be * used to collect coverage from that part of code. |
eec028c93 kcov: remote cove... |
714 715 716 717 718 719 720 721 722 723 |
* * The handle argument of kcov_remote_start() identifies a code section that is * used for coverage collection. A userspace process passes this handle to * KCOV_REMOTE_ENABLE ioctl to make the used kcov device start collecting * coverage for the code section identified by this handle. * * The usage of these annotations in the kernel code is different depending on * the type of the kernel thread whose code is being annotated. * * For global kernel threads that are spawned in a limited number of instances |
5ff3b30ab kcov: collect cov... |
724 725 726 |
* (e.g. one USB hub_event() worker thread is spawned per USB HCD) and for * softirqs, each instance must be assigned a unique 4-byte instance id. The * instance id is then combined with a 1-byte subsystem id to get a handle via |
eec028c93 kcov: remote cove... |
727 728 729 730 731 732 733 734 735 |
* kcov_remote_handle(subsystem_id, instance_id). * * For local kernel threads that are spawned from system calls handler when a * user interacts with some kernel interface (e.g. vhost workers), a handle is * passed from a userspace process as the common_handle field of the * kcov_remote_arg struct (note, that the user must generate a handle by using * kcov_remote_handle() with KCOV_SUBSYSTEM_COMMON as the subsystem id and an * arbitrary 4-byte non-zero number as the instance id). This common handle * then gets saved into the task_struct of the process that issued the |
324cfb195 kernel/kcov.c: fi... |
736 737 |
* KCOV_REMOTE_ENABLE ioctl. When this process issues system calls that spawn * kernel threads, the common handle must be retrieved via kcov_common_handle() |
eec028c93 kcov: remote cove... |
738 739 740 741 742 743 744 |
* and passed to the spawned threads via custom annotations. Those kernel * threads must in turn be annotated with kcov_remote_start(common_handle) and * kcov_remote_stop(). All of the threads that are spawned by the same process * obtain the same handle, hence the name "common". * * See Documentation/dev-tools/kcov.rst for more details. * |
5ff3b30ab kcov: collect cov... |
745 |
* Internally, kcov_remote_start() looks up the kcov device associated with the |
eec028c93 kcov: remote cove... |
746 747 |
* provided handle, allocates an area for coverage collection, and saves the * pointers to kcov and area into the current task_struct to allow coverage to |
3021e6921 kcov: check kcov_... |
748 |
* be collected via __sanitizer_cov_trace_pc(). |
eec028c93 kcov: remote cove... |
749 750 751 |
* In turns kcov_remote_stop() clears those pointers from task_struct to stop * collecting coverage and copies all collected coverage into the kcov area. */ |
5fe7042dc kcov: use t->kcov... |
752 753 754 755 756 |
static inline bool kcov_mode_enabled(unsigned int mode) { return (mode & ~KCOV_IN_CTXSW) != KCOV_MODE_DISABLED; } |
fed79d057 kcov: make some s... |
757 |
static void kcov_remote_softirq_start(struct task_struct *t) |
5ff3b30ab kcov: collect cov... |
758 759 760 761 762 763 764 765 766 767 768 769 770 771 772 |
{ struct kcov_percpu_data *data = this_cpu_ptr(&kcov_percpu_data); unsigned int mode; mode = READ_ONCE(t->kcov_mode); barrier(); if (kcov_mode_enabled(mode)) { data->saved_mode = mode; data->saved_size = t->kcov_size; data->saved_area = t->kcov_area; data->saved_sequence = t->kcov_sequence; data->saved_kcov = t->kcov; kcov_stop(t); } } |
fed79d057 kcov: make some s... |
773 |
static void kcov_remote_softirq_stop(struct task_struct *t) |
5ff3b30ab kcov: collect cov... |
774 775 776 777 778 779 780 781 782 783 784 785 786 787 |
{ struct kcov_percpu_data *data = this_cpu_ptr(&kcov_percpu_data); if (data->saved_kcov) { kcov_start(t, data->saved_kcov, data->saved_size, data->saved_area, data->saved_mode, data->saved_sequence); data->saved_mode = 0; data->saved_size = 0; data->saved_area = NULL; data->saved_sequence = 0; data->saved_kcov = NULL; } } |
eec028c93 kcov: remote cove... |
788 789 |
void kcov_remote_start(u64 handle) { |
5fe7042dc kcov: use t->kcov... |
790 |
struct task_struct *t = current; |
eec028c93 kcov: remote cove... |
791 |
struct kcov_remote *remote; |
67b3d3cca kcov: fix potenti... |
792 |
struct kcov *kcov; |
5fe7042dc kcov: use t->kcov... |
793 |
unsigned int mode; |
eec028c93 kcov: remote cove... |
794 |
void *area; |
eec028c93 kcov: remote cove... |
795 |
unsigned int size; |
eec028c93 kcov: remote cove... |
796 |
int sequence; |
5ff3b30ab kcov: collect cov... |
797 |
unsigned long flags; |
eec028c93 kcov: remote cove... |
798 799 800 |
if (WARN_ON(!kcov_check_handle(handle, true, true, true))) return; |
5ff3b30ab kcov: collect cov... |
801 |
if (!in_task() && !in_serving_softirq()) |
eec028c93 kcov: remote cove... |
802 |
return; |
5fe7042dc kcov: use t->kcov... |
803 |
|
5ff3b30ab kcov: collect cov... |
804 |
local_irq_save(flags); |
eec028c93 kcov: remote cove... |
805 |
/* |
5ff3b30ab kcov: collect cov... |
806 807 |
* Check that kcov_remote_start() is not called twice in background * threads nor called by user tasks (with enabled kcov). |
eec028c93 kcov: remote cove... |
808 |
*/ |
5fe7042dc kcov: use t->kcov... |
809 |
mode = READ_ONCE(t->kcov_mode); |
5ff3b30ab kcov: collect cov... |
810 811 |
if (WARN_ON(in_task() && kcov_mode_enabled(mode))) { local_irq_restore(flags); |
eec028c93 kcov: remote cove... |
812 |
return; |
5ff3b30ab kcov: collect cov... |
813 814 815 816 817 818 819 820 821 822 |
} /* * Check that kcov_remote_start() is not called twice in softirqs. * Note, that kcov_remote_start() can be called from a softirq that * happened while collecting coverage from a background thread. */ if (WARN_ON(in_serving_softirq() && t->kcov_softirq)) { local_irq_restore(flags); return; } |
eec028c93 kcov: remote cove... |
823 824 825 826 |
spin_lock(&kcov_remote_lock); remote = kcov_remote_find(handle); if (!remote) { |
5ff3b30ab kcov: collect cov... |
827 |
spin_unlock_irqrestore(&kcov_remote_lock, flags); |
eec028c93 kcov: remote cove... |
828 829 |
return; } |
5ff3b30ab kcov: collect cov... |
830 831 832 |
kcov_debug("handle = %llx, context: %s ", handle, in_task() ? "task" : "softirq"); |
67b3d3cca kcov: fix potenti... |
833 |
kcov = remote->kcov; |
eec028c93 kcov: remote cove... |
834 |
/* Put in kcov_remote_stop(). */ |
67b3d3cca kcov: fix potenti... |
835 |
kcov_get(kcov); |
eec028c93 kcov: remote cove... |
836 837 838 839 |
/* * Read kcov fields before unlock to prevent races with * KCOV_DISABLE / kcov_remote_reset(). */ |
67b3d3cca kcov: fix potenti... |
840 841 |
mode = kcov->mode; sequence = kcov->sequence; |
5ff3b30ab kcov: collect cov... |
842 843 844 845 846 847 848 849 |
if (in_task()) { size = kcov->remote_size; area = kcov_remote_area_get(size); } else { size = CONFIG_KCOV_IRQ_AREA_SIZE; area = this_cpu_ptr(&kcov_percpu_data)->irq_area; } spin_unlock_irqrestore(&kcov_remote_lock, flags); |
eec028c93 kcov: remote cove... |
850 |
|
5ff3b30ab kcov: collect cov... |
851 |
/* Can only happen when in_task(). */ |
eec028c93 kcov: remote cove... |
852 853 854 |
if (!area) { area = vmalloc(size * sizeof(unsigned long)); if (!area) { |
67b3d3cca kcov: fix potenti... |
855 |
kcov_put(kcov); |
eec028c93 kcov: remote cove... |
856 857 858 |
return; } } |
5ff3b30ab kcov: collect cov... |
859 860 |
local_irq_save(flags); |
eec028c93 kcov: remote cove... |
861 862 |
/* Reset coverage size. */ *(u64 *)area = 0; |
5ff3b30ab kcov: collect cov... |
863 864 865 866 |
if (in_serving_softirq()) { kcov_remote_softirq_start(t); t->kcov_softirq = 1; } |
76484b1c7 kcov: move t->kco... |
867 |
kcov_start(t, kcov, size, area, mode, sequence); |
eec028c93 kcov: remote cove... |
868 |
|
5ff3b30ab kcov: collect cov... |
869 |
local_irq_restore(flags); |
eec028c93 kcov: remote cove... |
870 871 872 873 874 875 876 877 878 879 880 881 882 883 884 885 886 887 888 889 890 891 892 893 894 895 896 897 898 899 900 901 902 903 904 905 906 907 908 909 910 911 912 913 914 915 916 917 918 919 920 921 922 923 924 925 926 927 928 929 930 931 932 |
} EXPORT_SYMBOL(kcov_remote_start); static void kcov_move_area(enum kcov_mode mode, void *dst_area, unsigned int dst_area_size, void *src_area) { u64 word_size = sizeof(unsigned long); u64 count_size, entry_size_log; u64 dst_len, src_len; void *dst_entries, *src_entries; u64 dst_occupied, dst_free, bytes_to_move, entries_moved; kcov_debug("%px %u <= %px %lu ", dst_area, dst_area_size, src_area, *(unsigned long *)src_area); switch (mode) { case KCOV_MODE_TRACE_PC: dst_len = READ_ONCE(*(unsigned long *)dst_area); src_len = *(unsigned long *)src_area; count_size = sizeof(unsigned long); entry_size_log = __ilog2_u64(sizeof(unsigned long)); break; case KCOV_MODE_TRACE_CMP: dst_len = READ_ONCE(*(u64 *)dst_area); src_len = *(u64 *)src_area; count_size = sizeof(u64); BUILD_BUG_ON(!is_power_of_2(KCOV_WORDS_PER_CMP)); entry_size_log = __ilog2_u64(sizeof(u64) * KCOV_WORDS_PER_CMP); break; default: WARN_ON(1); return; } /* As arm can't divide u64 integers use log of entry size. */ if (dst_len > ((dst_area_size * word_size - count_size) >> entry_size_log)) return; dst_occupied = count_size + (dst_len << entry_size_log); dst_free = dst_area_size * word_size - dst_occupied; bytes_to_move = min(dst_free, src_len << entry_size_log); dst_entries = dst_area + dst_occupied; src_entries = src_area + count_size; memcpy(dst_entries, src_entries, bytes_to_move); entries_moved = bytes_to_move >> entry_size_log; switch (mode) { case KCOV_MODE_TRACE_PC: WRITE_ONCE(*(unsigned long *)dst_area, dst_len + entries_moved); break; case KCOV_MODE_TRACE_CMP: WRITE_ONCE(*(u64 *)dst_area, dst_len + entries_moved); break; default: break; } } /* See the comment before kcov_remote_start() for usage details. */ void kcov_remote_stop(void) { struct task_struct *t = current; |
5fe7042dc kcov: use t->kcov... |
933 934 935 936 937 |
struct kcov *kcov; unsigned int mode; void *area; unsigned int size; int sequence; |
5ff3b30ab kcov: collect cov... |
938 939 940 941 942 943 |
unsigned long flags; if (!in_task() && !in_serving_softirq()) return; local_irq_save(flags); |
eec028c93 kcov: remote cove... |
944 |
|
5fe7042dc kcov: use t->kcov... |
945 946 |
mode = READ_ONCE(t->kcov_mode); barrier(); |
5ff3b30ab kcov: collect cov... |
947 948 |
if (!kcov_mode_enabled(mode)) { local_irq_restore(flags); |
eec028c93 kcov: remote cove... |
949 |
return; |
5ff3b30ab kcov: collect cov... |
950 |
} |
3021e6921 kcov: check kcov_... |
951 952 953 954 955 956 957 958 959 |
/* * When in softirq, check if the corresponding kcov_remote_start() * actually found the remote handle and started collecting coverage. */ if (in_serving_softirq() && !t->kcov_softirq) { local_irq_restore(flags); return; } /* Make sure that kcov_softirq is only set when in softirq. */ |
5ff3b30ab kcov: collect cov... |
960 961 962 963 |
if (WARN_ON(!in_serving_softirq() && t->kcov_softirq)) { local_irq_restore(flags); return; } |
3021e6921 kcov: check kcov_... |
964 965 966 967 |
kcov = t->kcov; area = t->kcov_area; size = t->kcov_size; sequence = t->kcov_sequence; |
eec028c93 kcov: remote cove... |
968 |
kcov_stop(t); |
5ff3b30ab kcov: collect cov... |
969 970 971 972 |
if (in_serving_softirq()) { t->kcov_softirq = 0; kcov_remote_softirq_stop(t); } |
eec028c93 kcov: remote cove... |
973 974 975 976 |
spin_lock(&kcov->lock); /* * KCOV_DISABLE could have been called between kcov_remote_start() |
5ff3b30ab kcov: collect cov... |
977 |
* and kcov_remote_stop(), hence the sequence check. |
eec028c93 kcov: remote cove... |
978 |
*/ |
eec028c93 kcov: remote cove... |
979 980 981 |
if (sequence == kcov->sequence && kcov->remote) kcov_move_area(kcov->mode, kcov->area, kcov->size, area); spin_unlock(&kcov->lock); |
5ff3b30ab kcov: collect cov... |
982 983 984 985 986 |
if (in_task()) { spin_lock(&kcov_remote_lock); kcov_remote_area_put(area, size); spin_unlock(&kcov_remote_lock); } |
eec028c93 kcov: remote cove... |
987 |
|
5ff3b30ab kcov: collect cov... |
988 989 990 |
local_irq_restore(flags); /* Get in kcov_remote_start(). */ |
eec028c93 kcov: remote cove... |
991 992 993 994 995 996 997 998 999 1000 |
kcov_put(kcov); } EXPORT_SYMBOL(kcov_remote_stop); /* See the comment before kcov_remote_start() for usage details. */ u64 kcov_common_handle(void) { return current->kcov_handle; } EXPORT_SYMBOL(kcov_common_handle); |
5c9a8750a kernel: add kcov ... |
1001 1002 |
static int __init kcov_init(void) { |
5ff3b30ab kcov: collect cov... |
1003 1004 1005 1006 1007 1008 1009 1010 1011 |
int cpu; for_each_possible_cpu(cpu) { void *area = vmalloc(CONFIG_KCOV_IRQ_AREA_SIZE * sizeof(unsigned long)); if (!area) return -ENOMEM; per_cpu_ptr(&kcov_percpu_data, cpu)->irq_area = area; } |
df4565f9e kernel/kcov: unpr... |
1012 1013 1014 1015 1016 |
/* * The kcov debugfs file won't ever get removed and thus, * there is no need to protect it against removal races. The * use of debugfs_create_file_unsafe() is actually safe here. */ |
ec9672d57 kcov: no need to ... |
1017 |
debugfs_create_file_unsafe("kcov", 0600, NULL, NULL, &kcov_fops); |
5c9a8750a kernel: add kcov ... |
1018 1019 1020 1021 |
return 0; } device_initcall(kcov_init); |