1 kcov: code coverage for fuzzing
2 ===============================
4 kcov exposes kernel code coverage information in a form suitable for coverage-
5 guided fuzzing (randomized testing). Coverage data of a running kernel is
6 exported via the "kcov" debugfs file. Coverage collection is enabled on a task
7 basis, and thus it can capture precise coverage of a single system call.
9 Note that kcov does not aim to collect as much coverage as possible. It aims
10 to collect more or less stable coverage that is function of syscall inputs.
11 To achieve this goal it does not collect coverage in soft/hard interrupts
12 and instrumentation of some inherently non-deterministic parts of kernel is
13 disabled (e.g. scheduler, locking).
15 kcov is also able to collect comparison operands from the instrumented code
16 (this feature currently requires that the kernel is compiled with clang).
21 Configure the kernel with::
25 CONFIG_KCOV requires gcc 6.1.0 or later.
27 If the comparison operands need to be collected, set::
29 CONFIG_KCOV_ENABLE_COMPARISONS=y
31 Profiling data will only become accessible once debugfs has been mounted::
33 mount -t debugfs none /sys/kernel/debug
38 The following program demonstrates coverage collection from within a test
47 #include <sys/types.h>
49 #include <sys/ioctl.h>
53 #include <linux/types.h>
55 #define KCOV_INIT_TRACE _IOR('c', 1, unsigned long)
56 #define KCOV_ENABLE _IO('c', 100)
57 #define KCOV_DISABLE _IO('c', 101)
58 #define COVER_SIZE (64<<10)
60 #define KCOV_TRACE_PC 0
61 #define KCOV_TRACE_CMP 1
63 int main(int argc, char **argv)
66 unsigned long *cover, n, i;
68 /* A single fd descriptor allows coverage collection on a single
71 fd = open("/sys/kernel/debug/kcov", O_RDWR);
73 perror("open"), exit(1);
74 /* Setup trace mode and trace size. */
75 if (ioctl(fd, KCOV_INIT_TRACE, COVER_SIZE))
76 perror("ioctl"), exit(1);
77 /* Mmap buffer shared between kernel- and user-space. */
78 cover = (unsigned long*)mmap(NULL, COVER_SIZE * sizeof(unsigned long),
79 PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
80 if ((void*)cover == MAP_FAILED)
81 perror("mmap"), exit(1);
82 /* Enable coverage collection on the current thread. */
83 if (ioctl(fd, KCOV_ENABLE, KCOV_TRACE_PC))
84 perror("ioctl"), exit(1);
85 /* Reset coverage from the tail of the ioctl() call. */
86 __atomic_store_n(&cover[0], 0, __ATOMIC_RELAXED);
87 /* That's the target syscal call. */
89 /* Read number of PCs collected. */
90 n = __atomic_load_n(&cover[0], __ATOMIC_RELAXED);
91 for (i = 0; i < n; i++)
92 printf("0x%lx\n", cover[i + 1]);
93 /* Disable coverage collection for the current thread. After this call
94 * coverage can be enabled for a different thread.
96 if (ioctl(fd, KCOV_DISABLE, 0))
97 perror("ioctl"), exit(1);
99 if (munmap(cover, COVER_SIZE * sizeof(unsigned long)))
100 perror("munmap"), exit(1);
102 perror("close"), exit(1);
106 After piping through addr2line output of the program looks as follows::
123 If a program needs to collect coverage from several threads (independently),
124 it needs to open /sys/kernel/debug/kcov in each thread separately.
126 The interface is fine-grained to allow efficient forking of test processes.
127 That is, a parent process opens /sys/kernel/debug/kcov, enables trace mode,
128 mmaps coverage buffer and then forks child processes in a loop. Child processes
129 only need to enable coverage (disable happens automatically on thread end).
131 Comparison operands collection
132 ------------------------------
134 Comparison operands collection is similar to coverage collection:
138 /* Same includes and defines as above. */
140 /* Number of 64-bit words per record. */
141 #define KCOV_WORDS_PER_CMP 4
144 * The format for the types of collected comparisons.
146 * Bit 0 shows whether one of the arguments is a compile-time constant.
147 * Bits 1 & 2 contain log2 of the argument size, up to 8 bytes.
150 #define KCOV_CMP_CONST (1 << 0)
151 #define KCOV_CMP_SIZE(n) ((n) << 1)
152 #define KCOV_CMP_MASK KCOV_CMP_SIZE(3)
154 int main(int argc, char **argv)
157 uint64_t *cover, type, arg1, arg2, is_const, size;
160 fd = open("/sys/kernel/debug/kcov", O_RDWR);
162 perror("open"), exit(1);
163 if (ioctl(fd, KCOV_INIT_TRACE, COVER_SIZE))
164 perror("ioctl"), exit(1);
166 * Note that the buffer pointer is of type uint64_t*, because all
167 * the comparison operands are promoted to uint64_t.
169 cover = (uint64_t *)mmap(NULL, COVER_SIZE * sizeof(unsigned long),
170 PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
171 if ((void*)cover == MAP_FAILED)
172 perror("mmap"), exit(1);
173 /* Note KCOV_TRACE_CMP instead of KCOV_TRACE_PC. */
174 if (ioctl(fd, KCOV_ENABLE, KCOV_TRACE_CMP))
175 perror("ioctl"), exit(1);
176 __atomic_store_n(&cover[0], 0, __ATOMIC_RELAXED);
178 /* Read number of comparisons collected. */
179 n = __atomic_load_n(&cover[0], __ATOMIC_RELAXED);
180 for (i = 0; i < n; i++) {
183 type = cover[i * KCOV_WORDS_PER_CMP + 1];
184 /* arg1 and arg2 - operands of the comparison. */
185 arg1 = cover[i * KCOV_WORDS_PER_CMP + 2];
186 arg2 = cover[i * KCOV_WORDS_PER_CMP + 3];
187 /* ip - caller address. */
188 ip = cover[i * KCOV_WORDS_PER_CMP + 4];
189 /* size of the operands. */
190 size = 1 << ((type & KCOV_CMP_MASK) >> 1);
191 /* is_const - true if either operand is a compile-time constant.*/
192 is_const = type & KCOV_CMP_CONST;
193 printf("ip: 0x%lx type: 0x%lx, arg1: 0x%lx, arg2: 0x%lx, "
195 ip, type, arg1, arg2, size,
196 is_const ? "const" : "non-const");
198 if (ioctl(fd, KCOV_DISABLE, 0))
199 perror("ioctl"), exit(1);
200 /* Free resources. */
201 if (munmap(cover, COVER_SIZE * sizeof(unsigned long)))
202 perror("munmap"), exit(1);
204 perror("close"), exit(1);
208 Note that the kcov modes (coverage collection or comparison operands) are
211 Remote coverage collection
212 --------------------------
214 With KCOV_ENABLE coverage is collected only for syscalls that are issued
215 from the current process. With KCOV_REMOTE_ENABLE it's possible to collect
216 coverage for arbitrary parts of the kernel code, provided that those parts
217 are annotated with kcov_remote_start()/kcov_remote_stop().
219 This allows to collect coverage from two types of kernel background
220 threads: the global ones, that are spawned during kernel boot in a limited
221 number of instances (e.g. one USB hub_event() worker thread is spawned per
222 USB HCD); and the local ones, that are spawned when a user interacts with
223 some kernel interface (e.g. vhost workers); as well as from soft
226 To enable collecting coverage from a global background thread or from a
227 softirq, a unique global handle must be assigned and passed to the
228 corresponding kcov_remote_start() call. Then a userspace process can pass
229 a list of such handles to the KCOV_REMOTE_ENABLE ioctl in the handles
230 array field of the kcov_remote_arg struct. This will attach the used kcov
231 device to the code sections, that are referenced by those handles.
233 Since there might be many local background threads spawned from different
234 userspace processes, we can't use a single global handle per annotation.
235 Instead, the userspace process passes a non-zero handle through the
236 common_handle field of the kcov_remote_arg struct. This common handle gets
237 saved to the kcov_handle field in the current task_struct and needs to be
238 passed to the newly spawned threads via custom annotations. Those threads
239 should in turn be annotated with kcov_remote_start()/kcov_remote_stop().
241 Internally kcov stores handles as u64 integers. The top byte of a handle
242 is used to denote the id of a subsystem that this handle belongs to, and
243 the lower 4 bytes are used to denote the id of a thread instance within
244 that subsystem. A reserved value 0 is used as a subsystem id for common
245 handles as they don't belong to a particular subsystem. The bytes 4-7 are
246 currently reserved and must be zero. In the future the number of bytes
247 used for the subsystem or handle ids might be increased.
249 When a particular userspace process collects coverage via a common
250 handle, kcov will collect coverage for each code section that is annotated
251 to use the common handle obtained as kcov_handle from the current
252 task_struct. However non common handles allow to collect coverage
253 selectively from different subsystems.
257 /* Same includes and defines as above. */
259 struct kcov_remote_arg {
263 __aligned_u64 common_handle;
264 __aligned_u64 handles[0];
267 #define KCOV_INIT_TRACE _IOR('c', 1, unsigned long)
268 #define KCOV_DISABLE _IO('c', 101)
269 #define KCOV_REMOTE_ENABLE _IOW('c', 102, struct kcov_remote_arg)
271 #define COVER_SIZE (64 << 10)
273 #define KCOV_TRACE_PC 0
275 #define KCOV_SUBSYSTEM_COMMON (0x00ull << 56)
276 #define KCOV_SUBSYSTEM_USB (0x01ull << 56)
278 #define KCOV_SUBSYSTEM_MASK (0xffull << 56)
279 #define KCOV_INSTANCE_MASK (0xffffffffull)
281 static inline __u64 kcov_remote_handle(__u64 subsys, __u64 inst)
283 if (subsys & ~KCOV_SUBSYSTEM_MASK || inst & ~KCOV_INSTANCE_MASK)
285 return subsys | inst;
288 #define KCOV_COMMON_ID 0x42
289 #define KCOV_USB_BUS_NUM 1
291 int main(int argc, char **argv)
294 unsigned long *cover, n, i;
295 struct kcov_remote_arg *arg;
297 fd = open("/sys/kernel/debug/kcov", O_RDWR);
299 perror("open"), exit(1);
300 if (ioctl(fd, KCOV_INIT_TRACE, COVER_SIZE))
301 perror("ioctl"), exit(1);
302 cover = (unsigned long*)mmap(NULL, COVER_SIZE * sizeof(unsigned long),
303 PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
304 if ((void*)cover == MAP_FAILED)
305 perror("mmap"), exit(1);
307 /* Enable coverage collection via common handle and from USB bus #1. */
308 arg = calloc(1, sizeof(*arg) + sizeof(uint64_t));
310 perror("calloc"), exit(1);
311 arg->trace_mode = KCOV_TRACE_PC;
312 arg->area_size = COVER_SIZE;
313 arg->num_handles = 1;
314 arg->common_handle = kcov_remote_handle(KCOV_SUBSYSTEM_COMMON,
316 arg->handles[0] = kcov_remote_handle(KCOV_SUBSYSTEM_USB,
318 if (ioctl(fd, KCOV_REMOTE_ENABLE, arg))
319 perror("ioctl"), free(arg), exit(1);
323 * Here the user needs to trigger execution of a kernel code section
324 * that is either annotated with the common handle, or to trigger some
325 * activity on USB bus #1.
329 n = __atomic_load_n(&cover[0], __ATOMIC_RELAXED);
330 for (i = 0; i < n; i++)
331 printf("0x%lx\n", cover[i + 1]);
332 if (ioctl(fd, KCOV_DISABLE, 0))
333 perror("ioctl"), exit(1);
334 if (munmap(cover, COVER_SIZE * sizeof(unsigned long)))
335 perror("munmap"), exit(1);
337 perror("close"), exit(1);