Loading...
Note: File does not exist in v5.14.15.
1// SPDX-License-Identifier: GPL-2.0
2/*
3 * This code provides functions to handle gcc's profiling data format
4 * introduced with gcc 3.4. Future versions of gcc may change the gcov
5 * format (as happened before), so all format-specific information needs
6 * to be kept modular and easily exchangeable.
7 *
8 * This file is based on gcc-internal definitions. Functions and data
9 * structures are defined to be compatible with gcc counterparts.
10 * For a better understanding, refer to gcc source: gcc/gcov-io.h.
11 *
12 * Copyright IBM Corp. 2009
13 * Author(s): Peter Oberparleiter <oberpar@linux.vnet.ibm.com>
14 *
15 * Uses gcc-internal data definitions.
16 */
17
18#include <linux/errno.h>
19#include <linux/slab.h>
20#include <linux/string.h>
21#include <linux/seq_file.h>
22#include <linux/vmalloc.h>
23#include "gcov.h"
24
25#define GCOV_COUNTERS 5
26
27static struct gcov_info *gcov_info_head;
28
29/**
30 * struct gcov_fn_info - profiling meta data per function
31 * @ident: object file-unique function identifier
32 * @checksum: function checksum
33 * @n_ctrs: number of values per counter type belonging to this function
34 *
35 * This data is generated by gcc during compilation and doesn't change
36 * at run-time.
37 */
38struct gcov_fn_info {
39 unsigned int ident;
40 unsigned int checksum;
41 unsigned int n_ctrs[0];
42};
43
44/**
45 * struct gcov_ctr_info - profiling data per counter type
46 * @num: number of counter values for this type
47 * @values: array of counter values for this type
48 * @merge: merge function for counter values of this type (unused)
49 *
50 * This data is generated by gcc during compilation and doesn't change
51 * at run-time with the exception of the values array.
52 */
53struct gcov_ctr_info {
54 unsigned int num;
55 gcov_type *values;
56 void (*merge)(gcov_type *, unsigned int);
57};
58
59/**
60 * struct gcov_info - profiling data per object file
61 * @version: gcov version magic indicating the gcc version used for compilation
62 * @next: list head for a singly-linked list
63 * @stamp: time stamp
64 * @filename: name of the associated gcov data file
65 * @n_functions: number of instrumented functions
66 * @functions: function data
67 * @ctr_mask: mask specifying which counter types are active
68 * @counts: counter data per counter type
69 *
70 * This data is generated by gcc during compilation and doesn't change
71 * at run-time with the exception of the next pointer.
72 */
73struct gcov_info {
74 unsigned int version;
75 struct gcov_info *next;
76 unsigned int stamp;
77 const char *filename;
78 unsigned int n_functions;
79 const struct gcov_fn_info *functions;
80 unsigned int ctr_mask;
81 struct gcov_ctr_info counts[0];
82};
83
84/**
85 * gcov_info_filename - return info filename
86 * @info: profiling data set
87 */
88const char *gcov_info_filename(struct gcov_info *info)
89{
90 return info->filename;
91}
92
93/**
94 * gcov_info_version - return info version
95 * @info: profiling data set
96 */
97unsigned int gcov_info_version(struct gcov_info *info)
98{
99 return info->version;
100}
101
102/**
103 * gcov_info_next - return next profiling data set
104 * @info: profiling data set
105 *
106 * Returns next gcov_info following @info or first gcov_info in the chain if
107 * @info is %NULL.
108 */
109struct gcov_info *gcov_info_next(struct gcov_info *info)
110{
111 if (!info)
112 return gcov_info_head;
113
114 return info->next;
115}
116
117/**
118 * gcov_info_link - link/add profiling data set to the list
119 * @info: profiling data set
120 */
121void gcov_info_link(struct gcov_info *info)
122{
123 info->next = gcov_info_head;
124 gcov_info_head = info;
125}
126
127/**
128 * gcov_info_unlink - unlink/remove profiling data set from the list
129 * @prev: previous profiling data set
130 * @info: profiling data set
131 */
132void gcov_info_unlink(struct gcov_info *prev, struct gcov_info *info)
133{
134 if (prev)
135 prev->next = info->next;
136 else
137 gcov_info_head = info->next;
138}
139
140/**
141 * gcov_info_within_module - check if a profiling data set belongs to a module
142 * @info: profiling data set
143 * @mod: module
144 *
145 * Returns true if profiling data belongs module, false otherwise.
146 */
147bool gcov_info_within_module(struct gcov_info *info, struct module *mod)
148{
149 return within_module((unsigned long)info, mod);
150}
151
152/* Symbolic links to be created for each profiling data file. */
153const struct gcov_link gcov_link[] = {
154 { OBJ_TREE, "gcno" }, /* Link to .gcno file in $(objtree). */
155 { 0, NULL},
156};
157
158/*
159 * Determine whether a counter is active. Based on gcc magic. Doesn't change
160 * at run-time.
161 */
162static int counter_active(struct gcov_info *info, unsigned int type)
163{
164 return (1 << type) & info->ctr_mask;
165}
166
167/* Determine number of active counters. Based on gcc magic. */
168static unsigned int num_counter_active(struct gcov_info *info)
169{
170 unsigned int i;
171 unsigned int result = 0;
172
173 for (i = 0; i < GCOV_COUNTERS; i++) {
174 if (counter_active(info, i))
175 result++;
176 }
177 return result;
178}
179
180/**
181 * gcov_info_reset - reset profiling data to zero
182 * @info: profiling data set
183 */
184void gcov_info_reset(struct gcov_info *info)
185{
186 unsigned int active = num_counter_active(info);
187 unsigned int i;
188
189 for (i = 0; i < active; i++) {
190 memset(info->counts[i].values, 0,
191 info->counts[i].num * sizeof(gcov_type));
192 }
193}
194
195/**
196 * gcov_info_is_compatible - check if profiling data can be added
197 * @info1: first profiling data set
198 * @info2: second profiling data set
199 *
200 * Returns non-zero if profiling data can be added, zero otherwise.
201 */
202int gcov_info_is_compatible(struct gcov_info *info1, struct gcov_info *info2)
203{
204 return (info1->stamp == info2->stamp);
205}
206
207/**
208 * gcov_info_add - add up profiling data
209 * @dest: profiling data set to which data is added
210 * @source: profiling data set which is added
211 *
212 * Adds profiling counts of @source to @dest.
213 */
214void gcov_info_add(struct gcov_info *dest, struct gcov_info *source)
215{
216 unsigned int i;
217 unsigned int j;
218
219 for (i = 0; i < num_counter_active(dest); i++) {
220 for (j = 0; j < dest->counts[i].num; j++) {
221 dest->counts[i].values[j] +=
222 source->counts[i].values[j];
223 }
224 }
225}
226
227/* Get size of function info entry. Based on gcc magic. */
228static size_t get_fn_size(struct gcov_info *info)
229{
230 size_t size;
231
232 size = sizeof(struct gcov_fn_info) + num_counter_active(info) *
233 sizeof(unsigned int);
234 if (__alignof__(struct gcov_fn_info) > sizeof(unsigned int))
235 size = ALIGN(size, __alignof__(struct gcov_fn_info));
236 return size;
237}
238
239/* Get address of function info entry. Based on gcc magic. */
240static struct gcov_fn_info *get_fn_info(struct gcov_info *info, unsigned int fn)
241{
242 return (struct gcov_fn_info *)
243 ((char *) info->functions + fn * get_fn_size(info));
244}
245
246/**
247 * gcov_info_dup - duplicate profiling data set
248 * @info: profiling data set to duplicate
249 *
250 * Return newly allocated duplicate on success, %NULL on error.
251 */
252struct gcov_info *gcov_info_dup(struct gcov_info *info)
253{
254 struct gcov_info *dup;
255 unsigned int i;
256 unsigned int active;
257
258 /* Duplicate gcov_info. */
259 active = num_counter_active(info);
260 dup = kzalloc(struct_size(dup, counts, active), GFP_KERNEL);
261 if (!dup)
262 return NULL;
263 dup->version = info->version;
264 dup->stamp = info->stamp;
265 dup->n_functions = info->n_functions;
266 dup->ctr_mask = info->ctr_mask;
267 /* Duplicate filename. */
268 dup->filename = kstrdup(info->filename, GFP_KERNEL);
269 if (!dup->filename)
270 goto err_free;
271 /* Duplicate table of functions. */
272 dup->functions = kmemdup(info->functions, info->n_functions *
273 get_fn_size(info), GFP_KERNEL);
274 if (!dup->functions)
275 goto err_free;
276 /* Duplicate counter arrays. */
277 for (i = 0; i < active ; i++) {
278 struct gcov_ctr_info *ctr = &info->counts[i];
279 size_t size = ctr->num * sizeof(gcov_type);
280
281 dup->counts[i].num = ctr->num;
282 dup->counts[i].merge = ctr->merge;
283 dup->counts[i].values = vmalloc(size);
284 if (!dup->counts[i].values)
285 goto err_free;
286 memcpy(dup->counts[i].values, ctr->values, size);
287 }
288 return dup;
289
290err_free:
291 gcov_info_free(dup);
292 return NULL;
293}
294
295/**
296 * gcov_info_free - release memory for profiling data set duplicate
297 * @info: profiling data set duplicate to free
298 */
299void gcov_info_free(struct gcov_info *info)
300{
301 unsigned int active = num_counter_active(info);
302 unsigned int i;
303
304 for (i = 0; i < active ; i++)
305 vfree(info->counts[i].values);
306 kfree(info->functions);
307 kfree(info->filename);
308 kfree(info);
309}
310
311/**
312 * struct type_info - iterator helper array
313 * @ctr_type: counter type
314 * @offset: index of the first value of the current function for this type
315 *
316 * This array is needed to convert the in-memory data format into the in-file
317 * data format:
318 *
319 * In-memory:
320 * for each counter type
321 * for each function
322 * values
323 *
324 * In-file:
325 * for each function
326 * for each counter type
327 * values
328 *
329 * See gcc source gcc/gcov-io.h for more information on data organization.
330 */
331struct type_info {
332 int ctr_type;
333 unsigned int offset;
334};
335
336/**
337 * struct gcov_iterator - specifies current file position in logical records
338 * @info: associated profiling data
339 * @record: record type
340 * @function: function number
341 * @type: counter type
342 * @count: index into values array
343 * @num_types: number of counter types
344 * @type_info: helper array to get values-array offset for current function
345 */
346struct gcov_iterator {
347 struct gcov_info *info;
348
349 int record;
350 unsigned int function;
351 unsigned int type;
352 unsigned int count;
353
354 int num_types;
355 struct type_info type_info[0];
356};
357
358static struct gcov_fn_info *get_func(struct gcov_iterator *iter)
359{
360 return get_fn_info(iter->info, iter->function);
361}
362
363static struct type_info *get_type(struct gcov_iterator *iter)
364{
365 return &iter->type_info[iter->type];
366}
367
368/**
369 * gcov_iter_new - allocate and initialize profiling data iterator
370 * @info: profiling data set to be iterated
371 *
372 * Return file iterator on success, %NULL otherwise.
373 */
374struct gcov_iterator *gcov_iter_new(struct gcov_info *info)
375{
376 struct gcov_iterator *iter;
377
378 iter = kzalloc(struct_size(iter, type_info, num_counter_active(info)),
379 GFP_KERNEL);
380 if (iter)
381 iter->info = info;
382
383 return iter;
384}
385
386/**
387 * gcov_iter_free - release memory for iterator
388 * @iter: file iterator to free
389 */
390void gcov_iter_free(struct gcov_iterator *iter)
391{
392 kfree(iter);
393}
394
395/**
396 * gcov_iter_get_info - return profiling data set for given file iterator
397 * @iter: file iterator
398 */
399struct gcov_info *gcov_iter_get_info(struct gcov_iterator *iter)
400{
401 return iter->info;
402}
403
404/**
405 * gcov_iter_start - reset file iterator to starting position
406 * @iter: file iterator
407 */
408void gcov_iter_start(struct gcov_iterator *iter)
409{
410 int i;
411
412 iter->record = 0;
413 iter->function = 0;
414 iter->type = 0;
415 iter->count = 0;
416 iter->num_types = 0;
417 for (i = 0; i < GCOV_COUNTERS; i++) {
418 if (counter_active(iter->info, i)) {
419 iter->type_info[iter->num_types].ctr_type = i;
420 iter->type_info[iter->num_types++].offset = 0;
421 }
422 }
423}
424
425/* Mapping of logical record number to actual file content. */
426#define RECORD_FILE_MAGIC 0
427#define RECORD_GCOV_VERSION 1
428#define RECORD_TIME_STAMP 2
429#define RECORD_FUNCTION_TAG 3
430#define RECORD_FUNCTON_TAG_LEN 4
431#define RECORD_FUNCTION_IDENT 5
432#define RECORD_FUNCTION_CHECK 6
433#define RECORD_COUNT_TAG 7
434#define RECORD_COUNT_LEN 8
435#define RECORD_COUNT 9
436
437/**
438 * gcov_iter_next - advance file iterator to next logical record
439 * @iter: file iterator
440 *
441 * Return zero if new position is valid, non-zero if iterator has reached end.
442 */
443int gcov_iter_next(struct gcov_iterator *iter)
444{
445 switch (iter->record) {
446 case RECORD_FILE_MAGIC:
447 case RECORD_GCOV_VERSION:
448 case RECORD_FUNCTION_TAG:
449 case RECORD_FUNCTON_TAG_LEN:
450 case RECORD_FUNCTION_IDENT:
451 case RECORD_COUNT_TAG:
452 /* Advance to next record */
453 iter->record++;
454 break;
455 case RECORD_COUNT:
456 /* Advance to next count */
457 iter->count++;
458 /* fall through */
459 case RECORD_COUNT_LEN:
460 if (iter->count < get_func(iter)->n_ctrs[iter->type]) {
461 iter->record = 9;
462 break;
463 }
464 /* Advance to next counter type */
465 get_type(iter)->offset += iter->count;
466 iter->count = 0;
467 iter->type++;
468 /* fall through */
469 case RECORD_FUNCTION_CHECK:
470 if (iter->type < iter->num_types) {
471 iter->record = 7;
472 break;
473 }
474 /* Advance to next function */
475 iter->type = 0;
476 iter->function++;
477 /* fall through */
478 case RECORD_TIME_STAMP:
479 if (iter->function < iter->info->n_functions)
480 iter->record = 3;
481 else
482 iter->record = -1;
483 break;
484 }
485 /* Check for EOF. */
486 if (iter->record == -1)
487 return -EINVAL;
488 else
489 return 0;
490}
491
492/**
493 * seq_write_gcov_u32 - write 32 bit number in gcov format to seq_file
494 * @seq: seq_file handle
495 * @v: value to be stored
496 *
497 * Number format defined by gcc: numbers are recorded in the 32 bit
498 * unsigned binary form of the endianness of the machine generating the
499 * file.
500 */
501static int seq_write_gcov_u32(struct seq_file *seq, u32 v)
502{
503 return seq_write(seq, &v, sizeof(v));
504}
505
506/**
507 * seq_write_gcov_u64 - write 64 bit number in gcov format to seq_file
508 * @seq: seq_file handle
509 * @v: value to be stored
510 *
511 * Number format defined by gcc: numbers are recorded in the 32 bit
512 * unsigned binary form of the endianness of the machine generating the
513 * file. 64 bit numbers are stored as two 32 bit numbers, the low part
514 * first.
515 */
516static int seq_write_gcov_u64(struct seq_file *seq, u64 v)
517{
518 u32 data[2];
519
520 data[0] = (v & 0xffffffffUL);
521 data[1] = (v >> 32);
522 return seq_write(seq, data, sizeof(data));
523}
524
525/**
526 * gcov_iter_write - write data for current pos to seq_file
527 * @iter: file iterator
528 * @seq: seq_file handle
529 *
530 * Return zero on success, non-zero otherwise.
531 */
532int gcov_iter_write(struct gcov_iterator *iter, struct seq_file *seq)
533{
534 int rc = -EINVAL;
535
536 switch (iter->record) {
537 case RECORD_FILE_MAGIC:
538 rc = seq_write_gcov_u32(seq, GCOV_DATA_MAGIC);
539 break;
540 case RECORD_GCOV_VERSION:
541 rc = seq_write_gcov_u32(seq, iter->info->version);
542 break;
543 case RECORD_TIME_STAMP:
544 rc = seq_write_gcov_u32(seq, iter->info->stamp);
545 break;
546 case RECORD_FUNCTION_TAG:
547 rc = seq_write_gcov_u32(seq, GCOV_TAG_FUNCTION);
548 break;
549 case RECORD_FUNCTON_TAG_LEN:
550 rc = seq_write_gcov_u32(seq, 2);
551 break;
552 case RECORD_FUNCTION_IDENT:
553 rc = seq_write_gcov_u32(seq, get_func(iter)->ident);
554 break;
555 case RECORD_FUNCTION_CHECK:
556 rc = seq_write_gcov_u32(seq, get_func(iter)->checksum);
557 break;
558 case RECORD_COUNT_TAG:
559 rc = seq_write_gcov_u32(seq,
560 GCOV_TAG_FOR_COUNTER(get_type(iter)->ctr_type));
561 break;
562 case RECORD_COUNT_LEN:
563 rc = seq_write_gcov_u32(seq,
564 get_func(iter)->n_ctrs[iter->type] * 2);
565 break;
566 case RECORD_COUNT:
567 rc = seq_write_gcov_u64(seq,
568 iter->info->counts[iter->type].
569 values[iter->count + get_type(iter)->offset]);
570 break;
571 }
572 return rc;
573}