1 KCOV: code coverage for fuzzing 1 KCOV: code coverage for fuzzing
2 =============================== 2 ===============================
3 3
4 KCOV collects and exposes kernel code coverage 4 KCOV collects and exposes kernel code coverage information in a form suitable
5 for coverage-guided fuzzing. Coverage data of 5 for coverage-guided fuzzing. Coverage data of a running kernel is exported via
6 the ``kcov`` debugfs file. Coverage collection 6 the ``kcov`` debugfs file. Coverage collection is enabled on a task basis, and
7 thus KCOV can capture precise coverage of a si 7 thus KCOV can capture precise coverage of a single system call.
8 8
9 Note that KCOV does not aim to collect as much 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 i 10 to collect more or less stable coverage that is a function of syscall inputs.
11 To achieve this goal, it does not collect cove 11 To achieve this goal, it does not collect coverage in soft/hard interrupts
12 (unless remove coverage collection is enabled, 12 (unless remove coverage collection is enabled, see below) and from some
13 inherently non-deterministic parts of the kern 13 inherently non-deterministic parts of the kernel (e.g. scheduler, locking).
14 14
15 Besides collecting code coverage, KCOV can als 15 Besides collecting code coverage, KCOV can also collect comparison operands.
16 See the "Comparison operands collection" secti 16 See the "Comparison operands collection" section for details.
17 17
18 Besides collecting coverage data from syscall 18 Besides collecting coverage data from syscall handlers, KCOV can also collect
19 coverage for annotated parts of the kernel exe 19 coverage for annotated parts of the kernel executing in background kernel
20 tasks or soft interrupts. See the "Remote cove 20 tasks or soft interrupts. See the "Remote coverage collection" section for
21 details. 21 details.
22 22
23 Prerequisites 23 Prerequisites
24 ------------- 24 -------------
25 25
26 KCOV relies on compiler instrumentation and re 26 KCOV relies on compiler instrumentation and requires GCC 6.1.0 or later
27 or any Clang version supported by the kernel. 27 or any Clang version supported by the kernel.
28 28
29 Collecting comparison operands is supported wi 29 Collecting comparison operands is supported with GCC 8+ or with Clang.
30 30
31 To enable KCOV, configure the kernel with:: 31 To enable KCOV, configure the kernel with::
32 32
33 CONFIG_KCOV=y 33 CONFIG_KCOV=y
34 34
35 To enable comparison operands collection, set: 35 To enable comparison operands collection, set::
36 36
37 CONFIG_KCOV_ENABLE_COMPARISONS=y 37 CONFIG_KCOV_ENABLE_COMPARISONS=y
38 38
39 Coverage data only becomes accessible once deb 39 Coverage data only becomes accessible once debugfs has been mounted::
40 40
41 mount -t debugfs none /sys/kernel/debu 41 mount -t debugfs none /sys/kernel/debug
42 42
43 Coverage collection 43 Coverage collection
44 ------------------- 44 -------------------
45 45
46 The following program demonstrates how to use 46 The following program demonstrates how to use KCOV to collect coverage for a
47 single syscall from within a test program: 47 single syscall from within a test program:
48 48
49 .. code-block:: c 49 .. code-block:: c
50 50
51 #include <stdio.h> 51 #include <stdio.h>
52 #include <stddef.h> 52 #include <stddef.h>
53 #include <stdint.h> 53 #include <stdint.h>
54 #include <stdlib.h> 54 #include <stdlib.h>
55 #include <sys/types.h> 55 #include <sys/types.h>
56 #include <sys/stat.h> 56 #include <sys/stat.h>
57 #include <sys/ioctl.h> 57 #include <sys/ioctl.h>
58 #include <sys/mman.h> 58 #include <sys/mman.h>
59 #include <unistd.h> 59 #include <unistd.h>
60 #include <fcntl.h> 60 #include <fcntl.h>
61 #include <linux/types.h> 61 #include <linux/types.h>
62 62
63 #define KCOV_INIT_TRACE 63 #define KCOV_INIT_TRACE _IOR('c', 1, unsigned long)
64 #define KCOV_ENABLE _IO('c 64 #define KCOV_ENABLE _IO('c', 100)
65 #define KCOV_DISABLE 65 #define KCOV_DISABLE _IO('c', 101)
66 #define COVER_SIZE (64<<1 66 #define COVER_SIZE (64<<10)
67 67
68 #define KCOV_TRACE_PC 0 68 #define KCOV_TRACE_PC 0
69 #define KCOV_TRACE_CMP 1 69 #define KCOV_TRACE_CMP 1
70 70
71 int main(int argc, char **argv) 71 int main(int argc, char **argv)
72 { 72 {
73 int fd; 73 int fd;
74 unsigned long *cover, n, i; 74 unsigned long *cover, n, i;
75 75
76 /* A single fd descriptor allows cover 76 /* A single fd descriptor allows coverage collection on a single
77 * thread. 77 * thread.
78 */ 78 */
79 fd = open("/sys/kernel/debug/kcov", O_ 79 fd = open("/sys/kernel/debug/kcov", O_RDWR);
80 if (fd == -1) 80 if (fd == -1)
81 perror("open"), exit(1); 81 perror("open"), exit(1);
82 /* Setup trace mode and trace size. */ 82 /* Setup trace mode and trace size. */
83 if (ioctl(fd, KCOV_INIT_TRACE, COVER_S 83 if (ioctl(fd, KCOV_INIT_TRACE, COVER_SIZE))
84 perror("ioctl"), exit(1); 84 perror("ioctl"), exit(1);
85 /* Mmap buffer shared between kernel- 85 /* Mmap buffer shared between kernel- and user-space. */
86 cover = (unsigned long*)mmap(NULL, COV 86 cover = (unsigned long*)mmap(NULL, COVER_SIZE * sizeof(unsigned long),
87 PROT_READ 87 PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
88 if ((void*)cover == MAP_FAILED) 88 if ((void*)cover == MAP_FAILED)
89 perror("mmap"), exit(1); 89 perror("mmap"), exit(1);
90 /* Enable coverage collection on the c 90 /* Enable coverage collection on the current thread. */
91 if (ioctl(fd, KCOV_ENABLE, KCOV_TRACE_ 91 if (ioctl(fd, KCOV_ENABLE, KCOV_TRACE_PC))
92 perror("ioctl"), exit(1); 92 perror("ioctl"), exit(1);
93 /* Reset coverage from the tail of the 93 /* Reset coverage from the tail of the ioctl() call. */
94 __atomic_store_n(&cover[0], 0, __ATOMI 94 __atomic_store_n(&cover[0], 0, __ATOMIC_RELAXED);
95 /* Call the target syscall call. */ 95 /* Call the target syscall call. */
96 read(-1, NULL, 0); 96 read(-1, NULL, 0);
97 /* Read number of PCs collected. */ 97 /* Read number of PCs collected. */
98 n = __atomic_load_n(&cover[0], __ATOMI 98 n = __atomic_load_n(&cover[0], __ATOMIC_RELAXED);
99 for (i = 0; i < n; i++) 99 for (i = 0; i < n; i++)
100 printf("0x%lx\n", cover[i + 1] 100 printf("0x%lx\n", cover[i + 1]);
101 /* Disable coverage collection for the 101 /* Disable coverage collection for the current thread. After this call
102 * coverage can be enabled for a diffe 102 * coverage can be enabled for a different thread.
103 */ 103 */
104 if (ioctl(fd, KCOV_DISABLE, 0)) 104 if (ioctl(fd, KCOV_DISABLE, 0))
105 perror("ioctl"), exit(1); 105 perror("ioctl"), exit(1);
106 /* Free resources. */ 106 /* Free resources. */
107 if (munmap(cover, COVER_SIZE * sizeof( 107 if (munmap(cover, COVER_SIZE * sizeof(unsigned long)))
108 perror("munmap"), exit(1); 108 perror("munmap"), exit(1);
109 if (close(fd)) 109 if (close(fd))
110 perror("close"), exit(1); 110 perror("close"), exit(1);
111 return 0; 111 return 0;
112 } 112 }
113 113
114 After piping through ``addr2line`` the output 114 After piping through ``addr2line`` the output of the program looks as follows::
115 115
116 SyS_read 116 SyS_read
117 fs/read_write.c:562 117 fs/read_write.c:562
118 __fdget_pos 118 __fdget_pos
119 fs/file.c:774 119 fs/file.c:774
120 __fget_light 120 __fget_light
121 fs/file.c:746 121 fs/file.c:746
122 __fget_light 122 __fget_light
123 fs/file.c:750 123 fs/file.c:750
124 __fget_light 124 __fget_light
125 fs/file.c:760 125 fs/file.c:760
126 __fdget_pos 126 __fdget_pos
127 fs/file.c:784 127 fs/file.c:784
128 SyS_read 128 SyS_read
129 fs/read_write.c:562 129 fs/read_write.c:562
130 130
131 If a program needs to collect coverage from se 131 If a program needs to collect coverage from several threads (independently),
132 it needs to open ``/sys/kernel/debug/kcov`` in 132 it needs to open ``/sys/kernel/debug/kcov`` in each thread separately.
133 133
134 The interface is fine-grained to allow efficie 134 The interface is fine-grained to allow efficient forking of test processes.
135 That is, a parent process opens ``/sys/kernel/ 135 That is, a parent process opens ``/sys/kernel/debug/kcov``, enables trace mode,
136 mmaps coverage buffer, and then forks child pr 136 mmaps coverage buffer, and then forks child processes in a loop. The child
137 processes only need to enable coverage (it get 137 processes only need to enable coverage (it gets disabled automatically when
138 a thread exits). 138 a thread exits).
139 139
140 Comparison operands collection 140 Comparison operands collection
141 ------------------------------ 141 ------------------------------
142 142
143 Comparison operands collection is similar to c 143 Comparison operands collection is similar to coverage collection:
144 144
145 .. code-block:: c 145 .. code-block:: c
146 146
147 /* Same includes and defines as above. */ 147 /* Same includes and defines as above. */
148 148
149 /* Number of 64-bit words per record. */ 149 /* Number of 64-bit words per record. */
150 #define KCOV_WORDS_PER_CMP 4 150 #define KCOV_WORDS_PER_CMP 4
151 151
152 /* 152 /*
153 * The format for the types of collected c 153 * The format for the types of collected comparisons.
154 * 154 *
155 * Bit 0 shows whether one of the argument 155 * Bit 0 shows whether one of the arguments is a compile-time constant.
156 * Bits 1 & 2 contain log2 of the argument 156 * Bits 1 & 2 contain log2 of the argument size, up to 8 bytes.
157 */ 157 */
158 158
159 #define KCOV_CMP_CONST (1 << 0) 159 #define KCOV_CMP_CONST (1 << 0)
160 #define KCOV_CMP_SIZE(n) ((n) << 1) 160 #define KCOV_CMP_SIZE(n) ((n) << 1)
161 #define KCOV_CMP_MASK KCOV_CMP_S 161 #define KCOV_CMP_MASK KCOV_CMP_SIZE(3)
162 162
163 int main(int argc, char **argv) 163 int main(int argc, char **argv)
164 { 164 {
165 int fd; 165 int fd;
166 uint64_t *cover, type, arg1, arg2, is_ 166 uint64_t *cover, type, arg1, arg2, is_const, size;
167 unsigned long n, i; 167 unsigned long n, i;
168 168
169 fd = open("/sys/kernel/debug/kcov", O_ 169 fd = open("/sys/kernel/debug/kcov", O_RDWR);
170 if (fd == -1) 170 if (fd == -1)
171 perror("open"), exit(1); 171 perror("open"), exit(1);
172 if (ioctl(fd, KCOV_INIT_TRACE, COVER_S 172 if (ioctl(fd, KCOV_INIT_TRACE, COVER_SIZE))
173 perror("ioctl"), exit(1); 173 perror("ioctl"), exit(1);
174 /* 174 /*
175 * Note that the buffer pointer is of t 175 * Note that the buffer pointer is of type uint64_t*, because all
176 * the comparison operands are promoted 176 * the comparison operands are promoted to uint64_t.
177 */ 177 */
178 cover = (uint64_t *)mmap(NULL, COVER_S 178 cover = (uint64_t *)mmap(NULL, COVER_SIZE * sizeof(unsigned long),
179 PROT_READ 179 PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
180 if ((void*)cover == MAP_FAILED) 180 if ((void*)cover == MAP_FAILED)
181 perror("mmap"), exit(1); 181 perror("mmap"), exit(1);
182 /* Note KCOV_TRACE_CMP instead of KCOV 182 /* Note KCOV_TRACE_CMP instead of KCOV_TRACE_PC. */
183 if (ioctl(fd, KCOV_ENABLE, KCOV_TRACE_ 183 if (ioctl(fd, KCOV_ENABLE, KCOV_TRACE_CMP))
184 perror("ioctl"), exit(1); 184 perror("ioctl"), exit(1);
185 __atomic_store_n(&cover[0], 0, __ATOMI 185 __atomic_store_n(&cover[0], 0, __ATOMIC_RELAXED);
186 read(-1, NULL, 0); 186 read(-1, NULL, 0);
187 /* Read number of comparisons collecte 187 /* Read number of comparisons collected. */
188 n = __atomic_load_n(&cover[0], __ATOMI 188 n = __atomic_load_n(&cover[0], __ATOMIC_RELAXED);
189 for (i = 0; i < n; i++) { 189 for (i = 0; i < n; i++) {
190 uint64_t ip; 190 uint64_t ip;
191 191
192 type = cover[i * KCOV_WORDS_PE 192 type = cover[i * KCOV_WORDS_PER_CMP + 1];
193 /* arg1 and arg2 - operands of 193 /* arg1 and arg2 - operands of the comparison. */
194 arg1 = cover[i * KCOV_WORDS_PE 194 arg1 = cover[i * KCOV_WORDS_PER_CMP + 2];
195 arg2 = cover[i * KCOV_WORDS_PE 195 arg2 = cover[i * KCOV_WORDS_PER_CMP + 3];
196 /* ip - caller address. */ 196 /* ip - caller address. */
197 ip = cover[i * KCOV_WORDS_PER_ 197 ip = cover[i * KCOV_WORDS_PER_CMP + 4];
198 /* size of the operands. */ 198 /* size of the operands. */
199 size = 1 << ((type & KCOV_CMP_ 199 size = 1 << ((type & KCOV_CMP_MASK) >> 1);
200 /* is_const - true if either o 200 /* is_const - true if either operand is a compile-time constant.*/
201 is_const = type & KCOV_CMP_CON 201 is_const = type & KCOV_CMP_CONST;
202 printf("ip: 0x%lx type: 0x%lx, 202 printf("ip: 0x%lx type: 0x%lx, arg1: 0x%lx, arg2: 0x%lx, "
203 "size: %lu, %s\n", 203 "size: %lu, %s\n",
204 ip, type, arg1, arg2, 204 ip, type, arg1, arg2, size,
205 is_const ? "const" : "non-cons 205 is_const ? "const" : "non-const");
206 } 206 }
207 if (ioctl(fd, KCOV_DISABLE, 0)) 207 if (ioctl(fd, KCOV_DISABLE, 0))
208 perror("ioctl"), exit(1); 208 perror("ioctl"), exit(1);
209 /* Free resources. */ 209 /* Free resources. */
210 if (munmap(cover, COVER_SIZE * sizeof( 210 if (munmap(cover, COVER_SIZE * sizeof(unsigned long)))
211 perror("munmap"), exit(1); 211 perror("munmap"), exit(1);
212 if (close(fd)) 212 if (close(fd))
213 perror("close"), exit(1); 213 perror("close"), exit(1);
214 return 0; 214 return 0;
215 } 215 }
216 216
217 Note that the KCOV modes (collection of code c 217 Note that the KCOV modes (collection of code coverage or comparison operands)
218 are mutually exclusive. 218 are mutually exclusive.
219 219
220 Remote coverage collection 220 Remote coverage collection
221 -------------------------- 221 --------------------------
222 222
223 Besides collecting coverage data from handlers 223 Besides collecting coverage data from handlers of syscalls issued from a
224 userspace process, KCOV can also collect cover 224 userspace process, KCOV can also collect coverage for parts of the kernel
225 executing in other contexts - so-called "remot 225 executing in other contexts - so-called "remote" coverage.
226 226
227 Using KCOV to collect remote coverage requires 227 Using KCOV to collect remote coverage requires:
228 228
229 1. Modifying kernel code to annotate the code 229 1. Modifying kernel code to annotate the code section from where coverage
230 should be collected with ``kcov_remote_star 230 should be collected with ``kcov_remote_start`` and ``kcov_remote_stop``.
231 231
232 2. Using ``KCOV_REMOTE_ENABLE`` instead of ``K 232 2. Using ``KCOV_REMOTE_ENABLE`` instead of ``KCOV_ENABLE`` in the userspace
233 process that collects coverage. 233 process that collects coverage.
234 234
235 Both ``kcov_remote_start`` and ``kcov_remote_s 235 Both ``kcov_remote_start`` and ``kcov_remote_stop`` annotations and the
236 ``KCOV_REMOTE_ENABLE`` ioctl accept handles th 236 ``KCOV_REMOTE_ENABLE`` ioctl accept handles that identify particular coverage
237 collection sections. The way a handle is used 237 collection sections. The way a handle is used depends on the context where the
238 matching code section executes. 238 matching code section executes.
239 239
240 KCOV supports collecting remote coverage from 240 KCOV supports collecting remote coverage from the following contexts:
241 241
242 1. Global kernel background tasks. These are t 242 1. Global kernel background tasks. These are the tasks that are spawned during
243 kernel boot in a limited number of instance 243 kernel boot in a limited number of instances (e.g. one USB ``hub_event``
244 worker is spawned per one USB HCD). 244 worker is spawned per one USB HCD).
245 245
246 2. Local kernel background tasks. These are sp 246 2. Local kernel background tasks. These are spawned when a userspace process
247 interacts with some kernel interface and ar 247 interacts with some kernel interface and are usually killed when the process
248 exits (e.g. vhost workers). 248 exits (e.g. vhost workers).
249 249
250 3. Soft interrupts. 250 3. Soft interrupts.
251 251
252 For #1 and #3, a unique global handle must be 252 For #1 and #3, a unique global handle must be chosen and passed to the
253 corresponding ``kcov_remote_start`` call. Then 253 corresponding ``kcov_remote_start`` call. Then a userspace process must pass
254 this handle to ``KCOV_REMOTE_ENABLE`` in the ` 254 this handle to ``KCOV_REMOTE_ENABLE`` in the ``handles`` array field of the
255 ``kcov_remote_arg`` struct. This will attach t 255 ``kcov_remote_arg`` struct. This will attach the used KCOV device to the code
256 section referenced by this handle. Multiple gl 256 section referenced by this handle. Multiple global handles identifying
257 different code sections can be passed at once. 257 different code sections can be passed at once.
258 258
259 For #2, the userspace process instead must pas 259 For #2, the userspace process instead must pass a non-zero handle through the
260 ``common_handle`` field of the ``kcov_remote_a 260 ``common_handle`` field of the ``kcov_remote_arg`` struct. This common handle
261 gets saved to the ``kcov_handle`` field in the 261 gets saved to the ``kcov_handle`` field in the current ``task_struct`` and
262 needs to be passed to the newly spawned local 262 needs to be passed to the newly spawned local tasks via custom kernel code
263 modifications. Those tasks should in turn use 263 modifications. Those tasks should in turn use the passed handle in their
264 ``kcov_remote_start`` and ``kcov_remote_stop`` 264 ``kcov_remote_start`` and ``kcov_remote_stop`` annotations.
265 265
266 KCOV follows a predefined format for both glob 266 KCOV follows a predefined format for both global and common handles. Each
267 handle is a ``u64`` integer. Currently, only t 267 handle is a ``u64`` integer. Currently, only the one top and the lower 4 bytes
268 are used. Bytes 4-7 are reserved and must be z 268 are used. Bytes 4-7 are reserved and must be zero.
269 269
270 For global handles, the top byte of the handle 270 For global handles, the top byte of the handle denotes the id of a subsystem
271 this handle belongs to. For example, KCOV uses 271 this handle belongs to. For example, KCOV uses ``1`` as the USB subsystem id.
272 The lower 4 bytes of a global handle denote th 272 The lower 4 bytes of a global handle denote the id of a task instance within
273 that subsystem. For example, each ``hub_event` 273 that subsystem. For example, each ``hub_event`` worker uses the USB bus number
274 as the task instance id. 274 as the task instance id.
275 275
276 For common handles, a reserved value ``0`` is 276 For common handles, a reserved value ``0`` is used as a subsystem id, as such
277 handles don't belong to a particular subsystem 277 handles don't belong to a particular subsystem. The lower 4 bytes of a common
278 handle identify a collective instance of all l 278 handle identify a collective instance of all local tasks spawned by the
279 userspace process that passed a common handle 279 userspace process that passed a common handle to ``KCOV_REMOTE_ENABLE``.
280 280
281 In practice, any value can be used for common 281 In practice, any value can be used for common handle instance id if coverage
282 is only collected from a single userspace proc 282 is only collected from a single userspace process on the system. However, if
283 common handles are used by multiple processes, 283 common handles are used by multiple processes, unique instance ids must be
284 used for each process. One option is to use th 284 used for each process. One option is to use the process id as the common
285 handle instance id. 285 handle instance id.
286 286
287 The following program demonstrates using KCOV 287 The following program demonstrates using KCOV to collect coverage from both
288 local tasks spawned by the process and the glo 288 local tasks spawned by the process and the global task that handles USB bus #1:
289 289
290 .. code-block:: c 290 .. code-block:: c
291 291
292 /* Same includes and defines as above. */ 292 /* Same includes and defines as above. */
293 293
294 struct kcov_remote_arg { 294 struct kcov_remote_arg {
295 __u32 trace_mode; 295 __u32 trace_mode;
296 __u32 area_size; 296 __u32 area_size;
297 __u32 num_handles; 297 __u32 num_handles;
298 __aligned_u64 common_handle; 298 __aligned_u64 common_handle;
299 __aligned_u64 handles[0]; 299 __aligned_u64 handles[0];
300 }; 300 };
301 301
302 #define KCOV_INIT_TRACE 302 #define KCOV_INIT_TRACE _IOR('c', 1, unsigned long)
303 #define KCOV_DISABLE 303 #define KCOV_DISABLE _IO('c', 101)
304 #define KCOV_REMOTE_ENABLE _IOW(' 304 #define KCOV_REMOTE_ENABLE _IOW('c', 102, struct kcov_remote_arg)
305 305
306 #define COVER_SIZE (64 << 10) 306 #define COVER_SIZE (64 << 10)
307 307
308 #define KCOV_TRACE_PC 0 308 #define KCOV_TRACE_PC 0
309 309
310 #define KCOV_SUBSYSTEM_COMMON (0x00u 310 #define KCOV_SUBSYSTEM_COMMON (0x00ull << 56)
311 #define KCOV_SUBSYSTEM_USB (0x01ull << 56 311 #define KCOV_SUBSYSTEM_USB (0x01ull << 56)
312 312
313 #define KCOV_SUBSYSTEM_MASK (0xffull << 56 313 #define KCOV_SUBSYSTEM_MASK (0xffull << 56)
314 #define KCOV_INSTANCE_MASK (0xffffffffull 314 #define KCOV_INSTANCE_MASK (0xffffffffull)
315 315
316 static inline __u64 kcov_remote_handle(__u 316 static inline __u64 kcov_remote_handle(__u64 subsys, __u64 inst)
317 { 317 {
318 if (subsys & ~KCOV_SUBSYSTEM_MASK || i 318 if (subsys & ~KCOV_SUBSYSTEM_MASK || inst & ~KCOV_INSTANCE_MASK)
319 return 0; 319 return 0;
320 return subsys | inst; 320 return subsys | inst;
321 } 321 }
322 322
323 #define KCOV_COMMON_ID 0x42 323 #define KCOV_COMMON_ID 0x42
324 #define KCOV_USB_BUS_NUM 1 324 #define KCOV_USB_BUS_NUM 1
325 325
326 int main(int argc, char **argv) 326 int main(int argc, char **argv)
327 { 327 {
328 int fd; 328 int fd;
329 unsigned long *cover, n, i; 329 unsigned long *cover, n, i;
330 struct kcov_remote_arg *arg; 330 struct kcov_remote_arg *arg;
331 331
332 fd = open("/sys/kernel/debug/kcov", O_ 332 fd = open("/sys/kernel/debug/kcov", O_RDWR);
333 if (fd == -1) 333 if (fd == -1)
334 perror("open"), exit(1); 334 perror("open"), exit(1);
335 if (ioctl(fd, KCOV_INIT_TRACE, COVER_S 335 if (ioctl(fd, KCOV_INIT_TRACE, COVER_SIZE))
336 perror("ioctl"), exit(1); 336 perror("ioctl"), exit(1);
337 cover = (unsigned long*)mmap(NULL, COV 337 cover = (unsigned long*)mmap(NULL, COVER_SIZE * sizeof(unsigned long),
338 PROT_READ 338 PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
339 if ((void*)cover == MAP_FAILED) 339 if ((void*)cover == MAP_FAILED)
340 perror("mmap"), exit(1); 340 perror("mmap"), exit(1);
341 341
342 /* Enable coverage collection via comm 342 /* Enable coverage collection via common handle and from USB bus #1. */
343 arg = calloc(1, sizeof(*arg) + sizeof( 343 arg = calloc(1, sizeof(*arg) + sizeof(uint64_t));
344 if (!arg) 344 if (!arg)
345 perror("calloc"), exit(1); 345 perror("calloc"), exit(1);
346 arg->trace_mode = KCOV_TRACE_PC; 346 arg->trace_mode = KCOV_TRACE_PC;
347 arg->area_size = COVER_SIZE; 347 arg->area_size = COVER_SIZE;
348 arg->num_handles = 1; 348 arg->num_handles = 1;
349 arg->common_handle = kcov_remote_handl 349 arg->common_handle = kcov_remote_handle(KCOV_SUBSYSTEM_COMMON,
350 350 KCOV_COMMON_ID);
351 arg->handles[0] = kcov_remote_handle(K 351 arg->handles[0] = kcov_remote_handle(KCOV_SUBSYSTEM_USB,
352 352 KCOV_USB_BUS_NUM);
353 if (ioctl(fd, KCOV_REMOTE_ENABLE, arg) 353 if (ioctl(fd, KCOV_REMOTE_ENABLE, arg))
354 perror("ioctl"), free(arg), ex 354 perror("ioctl"), free(arg), exit(1);
355 free(arg); 355 free(arg);
356 356
357 /* 357 /*
358 * Here the user needs to trigger exec 358 * Here the user needs to trigger execution of a kernel code section
359 * that is either annotated with the c 359 * that is either annotated with the common handle, or to trigger some
360 * activity on USB bus #1. 360 * activity on USB bus #1.
361 */ 361 */
362 sleep(2); 362 sleep(2);
363 363
364 n = __atomic_load_n(&cover[0], __ATOMI 364 n = __atomic_load_n(&cover[0], __ATOMIC_RELAXED);
365 for (i = 0; i < n; i++) 365 for (i = 0; i < n; i++)
366 printf("0x%lx\n", cover[i + 1] 366 printf("0x%lx\n", cover[i + 1]);
367 if (ioctl(fd, KCOV_DISABLE, 0)) 367 if (ioctl(fd, KCOV_DISABLE, 0))
368 perror("ioctl"), exit(1); 368 perror("ioctl"), exit(1);
369 if (munmap(cover, COVER_SIZE * sizeof( 369 if (munmap(cover, COVER_SIZE * sizeof(unsigned long)))
370 perror("munmap"), exit(1); 370 perror("munmap"), exit(1);
371 if (close(fd)) 371 if (close(fd))
372 perror("close"), exit(1); 372 perror("close"), exit(1);
373 return 0; 373 return 0;
374 } 374 }
Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.