1
2
3
4
5
6
7
8
9
10
11
12
13
14#include <linux/errno.h>
15#include <linux/slab.h>
16#include <linux/string.h>
17#include <linux/seq_file.h>
18#include <linux/vmalloc.h>
19#include "gcov.h"
20
21#if __GNUC__ == 5 && __GNUC_MINOR__ >= 1
22#define GCOV_COUNTERS 10
23#elif __GNUC__ == 4 && __GNUC_MINOR__ >= 9
24#define GCOV_COUNTERS 9
25#else
26#define GCOV_COUNTERS 8
27#endif
28
29#define GCOV_TAG_FUNCTION_LENGTH 3
30
31static struct gcov_info *gcov_info_head;
32
33
34
35
36
37
38
39
40
41struct gcov_ctr_info {
42 unsigned int num;
43 gcov_type *values;
44};
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63struct gcov_fn_info {
64 const struct gcov_info *key;
65 unsigned int ident;
66 unsigned int lineno_checksum;
67 unsigned int cfg_checksum;
68 struct gcov_ctr_info ctrs[0];
69};
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84struct gcov_info {
85 unsigned int version;
86 struct gcov_info *next;
87 unsigned int stamp;
88 const char *filename;
89 void (*merge[GCOV_COUNTERS])(gcov_type *, unsigned int);
90 unsigned int n_functions;
91 struct gcov_fn_info **functions;
92};
93
94
95
96
97
98const char *gcov_info_filename(struct gcov_info *info)
99{
100 return info->filename;
101}
102
103
104
105
106
107unsigned int gcov_info_version(struct gcov_info *info)
108{
109 return info->version;
110}
111
112
113
114
115
116
117
118
119struct gcov_info *gcov_info_next(struct gcov_info *info)
120{
121 if (!info)
122 return gcov_info_head;
123
124 return info->next;
125}
126
127
128
129
130
131void gcov_info_link(struct gcov_info *info)
132{
133 info->next = gcov_info_head;
134 gcov_info_head = info;
135}
136
137
138
139
140
141
142void gcov_info_unlink(struct gcov_info *prev, struct gcov_info *info)
143{
144 if (prev)
145 prev->next = info->next;
146 else
147 gcov_info_head = info->next;
148}
149
150
151const struct gcov_link gcov_link[] = {
152 { OBJ_TREE, "gcno" },
153 { 0, NULL},
154};
155
156
157
158
159static int counter_active(struct gcov_info *info, unsigned int type)
160{
161 return info->merge[type] ? 1 : 0;
162}
163
164
165static unsigned int num_counter_active(struct gcov_info *info)
166{
167 unsigned int i;
168 unsigned int result = 0;
169
170 for (i = 0; i < GCOV_COUNTERS; i++) {
171 if (counter_active(info, i))
172 result++;
173 }
174 return result;
175}
176
177
178
179
180
181void gcov_info_reset(struct gcov_info *info)
182{
183 struct gcov_ctr_info *ci_ptr;
184 unsigned int fi_idx;
185 unsigned int ct_idx;
186
187 for (fi_idx = 0; fi_idx < info->n_functions; fi_idx++) {
188 ci_ptr = info->functions[fi_idx]->ctrs;
189
190 for (ct_idx = 0; ct_idx < GCOV_COUNTERS; ct_idx++) {
191 if (!counter_active(info, ct_idx))
192 continue;
193
194 memset(ci_ptr->values, 0,
195 sizeof(gcov_type) * ci_ptr->num);
196 ci_ptr++;
197 }
198 }
199}
200
201
202
203
204
205
206
207
208int gcov_info_is_compatible(struct gcov_info *info1, struct gcov_info *info2)
209{
210 return (info1->stamp == info2->stamp);
211}
212
213
214
215
216
217
218
219
220void gcov_info_add(struct gcov_info *dst, struct gcov_info *src)
221{
222 struct gcov_ctr_info *dci_ptr;
223 struct gcov_ctr_info *sci_ptr;
224 unsigned int fi_idx;
225 unsigned int ct_idx;
226 unsigned int val_idx;
227
228 for (fi_idx = 0; fi_idx < src->n_functions; fi_idx++) {
229 dci_ptr = dst->functions[fi_idx]->ctrs;
230 sci_ptr = src->functions[fi_idx]->ctrs;
231
232 for (ct_idx = 0; ct_idx < GCOV_COUNTERS; ct_idx++) {
233 if (!counter_active(src, ct_idx))
234 continue;
235
236 for (val_idx = 0; val_idx < sci_ptr->num; val_idx++)
237 dci_ptr->values[val_idx] +=
238 sci_ptr->values[val_idx];
239
240 dci_ptr++;
241 sci_ptr++;
242 }
243 }
244}
245
246
247
248
249
250
251
252struct gcov_info *gcov_info_dup(struct gcov_info *info)
253{
254 struct gcov_info *dup;
255 struct gcov_ctr_info *dci_ptr;
256 struct gcov_ctr_info *sci_ptr;
257 unsigned int active;
258 unsigned int fi_idx;
259 unsigned int ct_idx;
260 size_t fi_size;
261 size_t cv_size;
262
263 dup = kmemdup(info, sizeof(*dup), GFP_KERNEL);
264 if (!dup)
265 return NULL;
266
267 dup->next = NULL;
268 dup->filename = NULL;
269 dup->functions = NULL;
270
271 dup->filename = kstrdup(info->filename, GFP_KERNEL);
272 if (!dup->filename)
273 goto err_free;
274
275 dup->functions = kcalloc(info->n_functions,
276 sizeof(struct gcov_fn_info *), GFP_KERNEL);
277 if (!dup->functions)
278 goto err_free;
279
280 active = num_counter_active(info);
281 fi_size = sizeof(struct gcov_fn_info);
282 fi_size += sizeof(struct gcov_ctr_info) * active;
283
284 for (fi_idx = 0; fi_idx < info->n_functions; fi_idx++) {
285 dup->functions[fi_idx] = kzalloc(fi_size, GFP_KERNEL);
286 if (!dup->functions[fi_idx])
287 goto err_free;
288
289 *(dup->functions[fi_idx]) = *(info->functions[fi_idx]);
290
291 sci_ptr = info->functions[fi_idx]->ctrs;
292 dci_ptr = dup->functions[fi_idx]->ctrs;
293
294 for (ct_idx = 0; ct_idx < active; ct_idx++) {
295
296 cv_size = sizeof(gcov_type) * sci_ptr->num;
297
298 dci_ptr->values = vmalloc(cv_size);
299
300 if (!dci_ptr->values)
301 goto err_free;
302
303 dci_ptr->num = sci_ptr->num;
304 memcpy(dci_ptr->values, sci_ptr->values, cv_size);
305
306 sci_ptr++;
307 dci_ptr++;
308 }
309 }
310
311 return dup;
312err_free:
313 gcov_info_free(dup);
314 return NULL;
315}
316
317
318
319
320
321void gcov_info_free(struct gcov_info *info)
322{
323 unsigned int active;
324 unsigned int fi_idx;
325 unsigned int ct_idx;
326 struct gcov_ctr_info *ci_ptr;
327
328 if (!info->functions)
329 goto free_info;
330
331 active = num_counter_active(info);
332
333 for (fi_idx = 0; fi_idx < info->n_functions; fi_idx++) {
334 if (!info->functions[fi_idx])
335 continue;
336
337 ci_ptr = info->functions[fi_idx]->ctrs;
338
339 for (ct_idx = 0; ct_idx < active; ct_idx++, ci_ptr++)
340 vfree(ci_ptr->values);
341
342 kfree(info->functions[fi_idx]);
343 }
344
345free_info:
346 kfree(info->functions);
347 kfree(info->filename);
348 kfree(info);
349}
350
351#define ITER_STRIDE PAGE_SIZE
352
353
354
355
356
357
358
359
360struct gcov_iterator {
361 struct gcov_info *info;
362 void *buffer;
363 size_t size;
364 loff_t pos;
365};
366
367
368
369
370
371
372
373
374
375
376
377
378static size_t store_gcov_u32(void *buffer, size_t off, u32 v)
379{
380 u32 *data;
381
382 if (buffer) {
383 data = buffer + off;
384 *data = v;
385 }
386
387 return sizeof(*data);
388}
389
390
391
392
393
394
395
396
397
398
399
400
401
402static size_t store_gcov_u64(void *buffer, size_t off, u64 v)
403{
404 u32 *data;
405
406 if (buffer) {
407 data = buffer + off;
408
409 data[0] = (v & 0xffffffffUL);
410 data[1] = (v >> 32);
411 }
412
413 return sizeof(*data) * 2;
414}
415
416
417
418
419
420
421
422
423static size_t convert_to_gcda(char *buffer, struct gcov_info *info)
424{
425 struct gcov_fn_info *fi_ptr;
426 struct gcov_ctr_info *ci_ptr;
427 unsigned int fi_idx;
428 unsigned int ct_idx;
429 unsigned int cv_idx;
430 size_t pos = 0;
431
432
433 pos += store_gcov_u32(buffer, pos, GCOV_DATA_MAGIC);
434 pos += store_gcov_u32(buffer, pos, info->version);
435 pos += store_gcov_u32(buffer, pos, info->stamp);
436
437 for (fi_idx = 0; fi_idx < info->n_functions; fi_idx++) {
438 fi_ptr = info->functions[fi_idx];
439
440
441 pos += store_gcov_u32(buffer, pos, GCOV_TAG_FUNCTION);
442 pos += store_gcov_u32(buffer, pos, GCOV_TAG_FUNCTION_LENGTH);
443 pos += store_gcov_u32(buffer, pos, fi_ptr->ident);
444 pos += store_gcov_u32(buffer, pos, fi_ptr->lineno_checksum);
445 pos += store_gcov_u32(buffer, pos, fi_ptr->cfg_checksum);
446
447 ci_ptr = fi_ptr->ctrs;
448
449 for (ct_idx = 0; ct_idx < GCOV_COUNTERS; ct_idx++) {
450 if (!counter_active(info, ct_idx))
451 continue;
452
453
454 pos += store_gcov_u32(buffer, pos,
455 GCOV_TAG_FOR_COUNTER(ct_idx));
456 pos += store_gcov_u32(buffer, pos, ci_ptr->num * 2);
457
458 for (cv_idx = 0; cv_idx < ci_ptr->num; cv_idx++) {
459 pos += store_gcov_u64(buffer, pos,
460 ci_ptr->values[cv_idx]);
461 }
462
463 ci_ptr++;
464 }
465 }
466
467 return pos;
468}
469
470
471
472
473
474
475
476struct gcov_iterator *gcov_iter_new(struct gcov_info *info)
477{
478 struct gcov_iterator *iter;
479
480 iter = kzalloc(sizeof(struct gcov_iterator), GFP_KERNEL);
481 if (!iter)
482 goto err_free;
483
484 iter->info = info;
485
486 iter->size = convert_to_gcda(NULL, info);
487 iter->buffer = vmalloc(iter->size);
488 if (!iter->buffer)
489 goto err_free;
490
491 convert_to_gcda(iter->buffer, info);
492
493 return iter;
494
495err_free:
496 kfree(iter);
497 return NULL;
498}
499
500
501
502
503
504
505void gcov_iter_free(struct gcov_iterator *iter)
506{
507 vfree(iter->buffer);
508 kfree(iter);
509}
510
511
512
513
514
515struct gcov_info *gcov_iter_get_info(struct gcov_iterator *iter)
516{
517 return iter->info;
518}
519
520
521
522
523
524void gcov_iter_start(struct gcov_iterator *iter)
525{
526 iter->pos = 0;
527}
528
529
530
531
532
533
534
535int gcov_iter_next(struct gcov_iterator *iter)
536{
537 if (iter->pos < iter->size)
538 iter->pos += ITER_STRIDE;
539
540 if (iter->pos >= iter->size)
541 return -EINVAL;
542
543 return 0;
544}
545
546
547
548
549
550
551
552
553int gcov_iter_write(struct gcov_iterator *iter, struct seq_file *seq)
554{
555 size_t len;
556
557 if (iter->pos >= iter->size)
558 return -EINVAL;
559
560 len = ITER_STRIDE;
561 if (iter->pos + len > iter->size)
562 len = iter->size - iter->pos;
563
564 seq_write(seq, iter->buffer + iter->pos, len);
565
566 return 0;
567}
568