kernel/kernel/gcov/gcc_4_7.c

   1 /*
   2  *  This code provides functions to handle gcc's profiling data format
   3  *  introduced with gcc 4.7.
   4  *
   5  *  This file is based heavily on gcc_3_4.c file.
   6  *
   7  *  For a better understanding, refer to gcc source:
   8  *  gcc/gcov-io.h
   9  *  libgcc/libgcov.c
  10  *
  11  *  Uses gcc-internal data definitions.
  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__ == 4 && __GNUC_MINOR__ >= 9
  22 #define GCOV_COUNTERS                   9
  23 #else
  24 #define GCOV_COUNTERS                   8
  25 #endif
  26
  27 #define GCOV_TAG_FUNCTION_LENGTH        3
  28
  29 static struct gcov_info *gcov_info_head;
  30
  31 /**
  32  * struct gcov_ctr_info - information about counters for a single function
  33  * @num: number of counter values for this type
  34  * @values: array of counter values for this type
  35  *
  36  * This data is generated by gcc during compilation and doesn't change
  37  * at run-time with the exception of the values array.
  38  */
  39 struct gcov_ctr_info {
  40         unsigned int num;
  41         gcov_type *values;
  42 };
  43
  44 /**
  45  * struct gcov_fn_info - profiling meta data per function
  46  * @key: comdat key
  47  * @ident: unique ident of function
  48  * @lineno_checksum: function lineo_checksum
  49  * @cfg_checksum: function cfg checksum
  50  * @ctrs: instrumented counters
  51  *
  52  * This data is generated by gcc during compilation and doesn't change
  53  * at run-time.
  54  *
  55  * Information about a single function.  This uses the trailing array
  56  * idiom. The number of counters is determined from the merge pointer
  57  * array in gcov_info.  The key is used to detect which of a set of
  58  * comdat functions was selected -- it points to the gcov_info object
  59  * of the object file containing the selected comdat function.
  60  */
  61 struct gcov_fn_info {
  62         const struct gcov_info *key;
  63         unsigned int ident;
  64         unsigned int lineno_checksum;
  65         unsigned int cfg_checksum;
  66         struct gcov_ctr_info ctrs[0];
  67 };
  68
  69 /**
  70  * struct gcov_info - profiling data per object file
  71  * @version: gcov version magic indicating the gcc version used for compilation
  72  * @next: list head for a singly-linked list
  73  * @stamp: uniquifying time stamp
  74  * @filename: name of the associated gcov data file
  75  * @merge: merge functions (null for unused counter type)
  76  * @n_functions: number of instrumented functions
  77  * @functions: pointer to pointers to function information
  78  *
  79  * This data is generated by gcc during compilation and doesn't change
  80  * at run-time with the exception of the next pointer.
  81  */
  82 struct gcov_info {
  83         unsigned int version;
  84         struct gcov_info *next;
  85         unsigned int stamp;
  86         const char *filename;
  87         void (*merge[GCOV_COUNTERS])(gcov_type *, unsigned int);
  88         unsigned int n_functions;
  89         struct gcov_fn_info **functions;
  90 };
  91
  92 /**
  93  * gcov_info_filename - return info filename
  94  * @info: profiling data set
  95  */
  96 const char *gcov_info_filename(struct gcov_info *info)
  97 {
  98         return info->filename;
  99 }
 100
 101 /**
 102  * gcov_info_version - return info version
 103  * @info: profiling data set
 104  */
 105 unsigned int gcov_info_version(struct gcov_info *info)
 106 {
 107         return info->version;
 108 }
 109
 110 /**
 111  * gcov_info_next - return next profiling data set
 112  * @info: profiling data set
 113  *
 114  * Returns next gcov_info following @info or first gcov_info in the chain if
 115  * @info is %NULL.
 116  */
 117 struct gcov_info *gcov_info_next(struct gcov_info *info)
 118 {
 119         if (!info)
 120                 return gcov_info_head;
 121
 122         return info->next;
 123 }
 124
 125 /**
 126  * gcov_info_link - link/add profiling data set to the list
 127  * @info: profiling data set
 128  */
 129 void gcov_info_link(struct gcov_info *info)
 130 {
 131         info->next = gcov_info_head;
 132         gcov_info_head = info;
 133 }
 134
 135 /**
 136  * gcov_info_unlink - unlink/remove profiling data set from the list
 137  * @prev: previous profiling data set
 138  * @info: profiling data set
 139  */
 140 void gcov_info_unlink(struct gcov_info *prev, struct gcov_info *info)
 141 {
 142         if (prev)
 143                 prev->next = info->next;
 144         else
 145                 gcov_info_head = info->next;
 146 }
 147
 148 /* Symbolic links to be created for each profiling data file. */
 149 const struct gcov_link gcov_link[] = {
 150         { OBJ_TREE, "gcno" },   /* Link to .gcno file in $(objtree). */
 151         { 0, NULL},
 152 };
 153
 154 /*
 155  * Determine whether a counter is active. Doesn't change at run-time.
 156  */
 157 static int counter_active(struct gcov_info *info, unsigned int type)
 158 {
 159         return info->merge[type] ? 1 : 0;
 160 }
 161
 162 /* Determine number of active counters. Based on gcc magic. */
 163 static unsigned int num_counter_active(struct gcov_info *info)
 164 {
 165         unsigned int i;
 166         unsigned int result = 0;
 167
 168         for (i = 0; i < GCOV_COUNTERS; i++) {
 169                 if (counter_active(info, i))
 170                         result++;
 171         }
 172         return result;
 173 }
 174
 175 /**
 176  * gcov_info_reset - reset profiling data to zero
 177  * @info: profiling data set
 178  */
 179 void gcov_info_reset(struct gcov_info *info)
 180 {
 181         struct gcov_ctr_info *ci_ptr;
 182         unsigned int fi_idx;
 183         unsigned int ct_idx;
 184
 185         for (fi_idx = 0; fi_idx < info->n_functions; fi_idx++) {
 186                 ci_ptr = info->functions[fi_idx]->ctrs;
 187
 188                 for (ct_idx = 0; ct_idx < GCOV_COUNTERS; ct_idx++) {
 189                         if (!counter_active(info, ct_idx))
 190                                 continue;
 191
 192                         memset(ci_ptr->values, 0,
 193                                         sizeof(gcov_type) * ci_ptr->num);
 194                         ci_ptr++;
 195                 }
 196         }
 197 }
 198
 199 /**
 200  * gcov_info_is_compatible - check if profiling data can be added
 201  * @info1: first profiling data set
 202  * @info2: second profiling data set
 203  *
 204  * Returns non-zero if profiling data can be added, zero otherwise.
 205  */
 206 int gcov_info_is_compatible(struct gcov_info *info1, struct gcov_info *info2)
 207 {
 208         return (info1->stamp == info2->stamp);
 209 }
 210
 211 /**
 212  * gcov_info_add - add up profiling data
 213  * @dest: profiling data set to which data is added
 214  * @source: profiling data set which is added
 215  *
 216  * Adds profiling counts of @source to @dest.
 217  */
 218 void gcov_info_add(struct gcov_info *dst, struct gcov_info *src)
 219 {
 220         struct gcov_ctr_info *dci_ptr;
 221         struct gcov_ctr_info *sci_ptr;
 222         unsigned int fi_idx;
 223         unsigned int ct_idx;
 224         unsigned int val_idx;
 225
 226         for (fi_idx = 0; fi_idx < src->n_functions; fi_idx++) {
 227                 dci_ptr = dst->functions[fi_idx]->ctrs;
 228                 sci_ptr = src->functions[fi_idx]->ctrs;
 229
 230                 for (ct_idx = 0; ct_idx < GCOV_COUNTERS; ct_idx++) {
 231                         if (!counter_active(src, ct_idx))
 232                                 continue;
 233
 234                         for (val_idx = 0; val_idx < sci_ptr->num; val_idx++)
 235                                 dci_ptr->values[val_idx] +=
 236                                         sci_ptr->values[val_idx];
 237
 238                         dci_ptr++;
 239                         sci_ptr++;
 240                 }
 241         }
 242 }
 243
 244 /**
 245  * gcov_info_dup - duplicate profiling data set
 246  * @info: profiling data set to duplicate
 247  *
 248  * Return newly allocated duplicate on success, %NULL on error.
 249  */
 250 struct gcov_info *gcov_info_dup(struct gcov_info *info)
 251 {
 252         struct gcov_info *dup;
 253         struct gcov_ctr_info *dci_ptr; /* dst counter info */
 254         struct gcov_ctr_info *sci_ptr; /* src counter info */
 255         unsigned int active;
 256         unsigned int fi_idx; /* function info idx */
 257         unsigned int ct_idx; /* counter type idx */
 258         size_t fi_size; /* function info size */
 259         size_t cv_size; /* counter values size */
 260
 261         dup = kmemdup(info, sizeof(*dup), GFP_KERNEL);
 262         if (!dup)
 263                 return NULL;
 264
 265         dup->next = NULL;
 266         dup->filename = NULL;
 267         dup->functions = NULL;
 268
 269         dup->filename = kstrdup(info->filename, GFP_KERNEL);
 270         if (!dup->filename)
 271                 goto err_free;
 272
 273         dup->functions = kcalloc(info->n_functions,
 274                                  sizeof(struct gcov_fn_info *), GFP_KERNEL);
 275         if (!dup->functions)
 276                 goto err_free;
 277
 278         active = num_counter_active(info);
 279         fi_size = sizeof(struct gcov_fn_info);
 280         fi_size += sizeof(struct gcov_ctr_info) * active;
 281
 282         for (fi_idx = 0; fi_idx < info->n_functions; fi_idx++) {
 283                 dup->functions[fi_idx] = kzalloc(fi_size, GFP_KERNEL);
 284                 if (!dup->functions[fi_idx])
 285                         goto err_free;
 286
 287                 *(dup->functions[fi_idx]) = *(info->functions[fi_idx]);
 288
 289                 sci_ptr = info->functions[fi_idx]->ctrs;
 290                 dci_ptr = dup->functions[fi_idx]->ctrs;
 291
 292                 for (ct_idx = 0; ct_idx < active; ct_idx++) {
 293
 294                         cv_size = sizeof(gcov_type) * sci_ptr->num;
 295
 296                         dci_ptr->values = vmalloc(cv_size);
 297
 298                         if (!dci_ptr->values)
 299                                 goto err_free;
 300
 301                         dci_ptr->num = sci_ptr->num;
 302                         memcpy(dci_ptr->values, sci_ptr->values, cv_size);
 303
 304                         sci_ptr++;
 305                         dci_ptr++;
 306                 }
 307         }
 308
 309         return dup;
 310 err_free:
 311         gcov_info_free(dup);
 312         return NULL;
 313 }
 314
 315 /**
 316  * gcov_info_free - release memory for profiling data set duplicate
 317  * @info: profiling data set duplicate to free
 318  */
 319 void gcov_info_free(struct gcov_info *info)
 320 {
 321         unsigned int active;
 322         unsigned int fi_idx;
 323         unsigned int ct_idx;
 324         struct gcov_ctr_info *ci_ptr;
 325
 326         if (!info->functions)
 327                 goto free_info;
 328
 329         active = num_counter_active(info);
 330
 331         for (fi_idx = 0; fi_idx < info->n_functions; fi_idx++) {
 332                 if (!info->functions[fi_idx])
 333                         continue;
 334
 335                 ci_ptr = info->functions[fi_idx]->ctrs;
 336
 337                 for (ct_idx = 0; ct_idx < active; ct_idx++, ci_ptr++)
 338                         vfree(ci_ptr->values);
 339
 340                 kfree(info->functions[fi_idx]);
 341         }
 342
 343 free_info:
 344         kfree(info->functions);
 345         kfree(info->filename);
 346         kfree(info);
 347 }
 348
 349 #define ITER_STRIDE     PAGE_SIZE
 350
 351 /**
 352  * struct gcov_iterator - specifies current file position in logical records
 353  * @info: associated profiling data
 354  * @buffer: buffer containing file data
 355  * @size: size of buffer
 356  * @pos: current position in file
 357  */
 358 struct gcov_iterator {
 359         struct gcov_info *info;
 360         void *buffer;
 361         size_t size;
 362         loff_t pos;
 363 };
 364
 365 /**
 366  * store_gcov_u32 - store 32 bit number in gcov format to buffer
 367  * @buffer: target buffer or NULL
 368  * @off: offset into the buffer
 369  * @v: value to be stored
 370  *
 371  * Number format defined by gcc: numbers are recorded in the 32 bit
 372  * unsigned binary form of the endianness of the machine generating the
 373  * file. Returns the number of bytes stored. If @buffer is %NULL, doesn't
 374  * store anything.
 375  */
 376 static size_t store_gcov_u32(void *buffer, size_t off, u32 v)
 377 {
 378         u32 *data;
 379
 380         if (buffer) {
 381                 data = buffer + off;
 382                 *data = v;
 383         }
 384
 385         return sizeof(*data);
 386 }
 387
 388 /**
 389  * store_gcov_u64 - store 64 bit number in gcov format to buffer
 390  * @buffer: target buffer or NULL
 391  * @off: offset into the buffer
 392  * @v: value to be stored
 393  *
 394  * Number format defined by gcc: numbers are recorded in the 32 bit
 395  * unsigned binary form of the endianness of the machine generating the
 396  * file. 64 bit numbers are stored as two 32 bit numbers, the low part
 397  * first. Returns the number of bytes stored. If @buffer is %NULL, doesn't store
 398  * anything.
 399  */
 400 static size_t store_gcov_u64(void *buffer, size_t off, u64 v)
 401 {
 402         u32 *data;
 403
 404         if (buffer) {
 405                 data = buffer + off;
 406
 407                 data[0] = (v & 0xffffffffUL);
 408                 data[1] = (v >> 32);
 409         }
 410
 411         return sizeof(*data) * 2;
 412 }
 413
 414 /**
 415  * convert_to_gcda - convert profiling data set to gcda file format
 416  * @buffer: the buffer to store file data or %NULL if no data should be stored
 417  * @info: profiling data set to be converted
 418  *
 419  * Returns the number of bytes that were/would have been stored into the buffer.
 420  */
 421 static size_t convert_to_gcda(char *buffer, struct gcov_info *info)
 422 {
 423         struct gcov_fn_info *fi_ptr;
 424         struct gcov_ctr_info *ci_ptr;
 425         unsigned int fi_idx;
 426         unsigned int ct_idx;
 427         unsigned int cv_idx;
 428         size_t pos = 0;
 429
 430         /* File header. */
 431         pos += store_gcov_u32(buffer, pos, GCOV_DATA_MAGIC);
 432         pos += store_gcov_u32(buffer, pos, info->version);
 433         pos += store_gcov_u32(buffer, pos, info->stamp);
 434
 435         for (fi_idx = 0; fi_idx < info->n_functions; fi_idx++) {
 436                 fi_ptr = info->functions[fi_idx];
 437
 438                 /* Function record. */
 439                 pos += store_gcov_u32(buffer, pos, GCOV_TAG_FUNCTION);
 440                 pos += store_gcov_u32(buffer, pos, GCOV_TAG_FUNCTION_LENGTH);
 441                 pos += store_gcov_u32(buffer, pos, fi_ptr->ident);
 442                 pos += store_gcov_u32(buffer, pos, fi_ptr->lineno_checksum);
 443                 pos += store_gcov_u32(buffer, pos, fi_ptr->cfg_checksum);
 444
 445                 ci_ptr = fi_ptr->ctrs;
 446
 447                 for (ct_idx = 0; ct_idx < GCOV_COUNTERS; ct_idx++) {
 448                         if (!counter_active(info, ct_idx))
 449                                 continue;
 450
 451                         /* Counter record. */
 452                         pos += store_gcov_u32(buffer, pos,
 453                                               GCOV_TAG_FOR_COUNTER(ct_idx));
 454                         pos += store_gcov_u32(buffer, pos, ci_ptr->num * 2);
 455
 456                         for (cv_idx = 0; cv_idx < ci_ptr->num; cv_idx++) {
 457                                 pos += store_gcov_u64(buffer, pos,
 458                                                       ci_ptr->values[cv_idx]);
 459                         }
 460
 461                         ci_ptr++;
 462                 }
 463         }
 464
 465         return pos;
 466 }
 467
 468 /**
 469  * gcov_iter_new - allocate and initialize profiling data iterator
 470  * @info: profiling data set to be iterated
 471  *
 472  * Return file iterator on success, %NULL otherwise.
 473  */
 474 struct gcov_iterator *gcov_iter_new(struct gcov_info *info)
 475 {
 476         struct gcov_iterator *iter;
 477
 478         iter = kzalloc(sizeof(struct gcov_iterator), GFP_KERNEL);
 479         if (!iter)
 480                 goto err_free;
 481
 482         iter->info = info;
 483         /* Dry-run to get the actual buffer size. */
 484         iter->size = convert_to_gcda(NULL, info);
 485         iter->buffer = vmalloc(iter->size);
 486         if (!iter->buffer)
 487                 goto err_free;
 488
 489         convert_to_gcda(iter->buffer, info);
 490
 491         return iter;
 492
 493 err_free:
 494         kfree(iter);
 495         return NULL;
 496 }
 497
 498
 499 /**
 500  * gcov_iter_get_info - return profiling data set for given file iterator
 501  * @iter: file iterator
 502  */
 503 void gcov_iter_free(struct gcov_iterator *iter)
 504 {
 505         vfree(iter->buffer);
 506         kfree(iter);
 507 }
 508
 509 /**
 510  * gcov_iter_get_info - return profiling data set for given file iterator
 511  * @iter: file iterator
 512  */
 513 struct gcov_info *gcov_iter_get_info(struct gcov_iterator *iter)
 514 {
 515         return iter->info;
 516 }
 517
 518 /**
 519  * gcov_iter_start - reset file iterator to starting position
 520  * @iter: file iterator
 521  */
 522 void gcov_iter_start(struct gcov_iterator *iter)
 523 {
 524         iter->pos = 0;
 525 }
 526
 527 /**
 528  * gcov_iter_next - advance file iterator to next logical record
 529  * @iter: file iterator
 530  *
 531  * Return zero if new position is valid, non-zero if iterator has reached end.
 532  */
 533 int gcov_iter_next(struct gcov_iterator *iter)
 534 {
 535         if (iter->pos < iter->size)
 536                 iter->pos += ITER_STRIDE;
 537
 538         if (iter->pos >= iter->size)
 539                 return -EINVAL;
 540
 541         return 0;
 542 }
 543
 544 /**
 545  * gcov_iter_write - write data for current pos to seq_file
 546  * @iter: file iterator
 547  * @seq: seq_file handle
 548  *
 549  * Return zero on success, non-zero otherwise.
 550  */
 551 int gcov_iter_write(struct gcov_iterator *iter, struct seq_file *seq)
 552 {
 553         size_t len;
 554
 555         if (iter->pos >= iter->size)
 556                 return -EINVAL;
 557
 558         len = ITER_STRIDE;
 559         if (iter->pos + len > iter->size)
 560                 len = iter->size - iter->pos;
 561
 562         seq_write(seq, iter->buffer + iter->pos, len);
 563
 564         return 0;
 565 }