tools/perf/util/session.c

   1 #define _FILE_OFFSET_BITS 64
   2
   3 #include <linux/kernel.h>
   4
   5 #include <byteswap.h>
   6 #include <unistd.h>
   7 #include <sys/types.h>
   8
   9 #include "session.h"
  10 #include "sort.h"
  11 #include "util.h"
  12
  13 static int perf_session__open(struct perf_session *self, bool force)
  14 {
  15         struct stat input_stat;
  16
  17         if (!strcmp(self->filename, "-")) {
  18                 self->fd_pipe = true;
  19                 self->fd = STDIN_FILENO;
  20
  21                 if (perf_header__read(self, self->fd) < 0)
  22                         pr_err("incompatible file format");
  23
  24                 return 0;
  25         }
  26
  27         self->fd = open(self->filename, O_RDONLY);
  28         if (self->fd < 0) {
  29                 pr_err("failed to open file: %s", self->filename);
  30                 if (!strcmp(self->filename, "perf.data"))
  31                         pr_err("  (try 'perf record' first)");
  32                 pr_err("\n");
  33                 return -errno;
  34         }
  35
  36         if (fstat(self->fd, &input_stat) < 0)
  37                 goto out_close;
  38
  39         if (!force && input_stat.st_uid && (input_stat.st_uid != geteuid())) {
  40                 pr_err("file %s not owned by current user or root\n",
  41                        self->filename);
  42                 goto out_close;
  43         }
  44
  45         if (!input_stat.st_size) {
  46                 pr_info("zero-sized file (%s), nothing to do!\n",
  47                         self->filename);
  48                 goto out_close;
  49         }
  50
  51         if (perf_header__read(self, self->fd) < 0) {
  52                 pr_err("incompatible file format");
  53                 goto out_close;
  54         }
  55
  56         self->size = input_stat.st_size;
  57         return 0;
  58
  59 out_close:
  60         close(self->fd);
  61         self->fd = -1;
  62         return -1;
  63 }
  64
  65 void perf_session__update_sample_type(struct perf_session *self)
  66 {
  67         self->sample_type = perf_header__sample_type(&self->header);
  68 }
  69
  70 struct perf_session *perf_session__new(const char *filename, int mode, bool force)
  71 {
  72         size_t len = filename ? strlen(filename) + 1 : 0;
  73         struct perf_session *self = zalloc(sizeof(*self) + len);
  74
  75         if (self == NULL)
  76                 goto out;
  77
  78         if (perf_header__init(&self->header) < 0)
  79                 goto out_free;
  80
  81         memcpy(self->filename, filename, len);
  82         self->threads = RB_ROOT;
  83         self->stats_by_id = RB_ROOT;
  84         self->last_match = NULL;
  85         self->mmap_window = 32;
  86         self->cwd = NULL;
  87         self->cwdlen = 0;
  88         self->unknown_events = 0;
  89         map_groups__init(&self->kmaps);
  90
  91         if (mode == O_RDONLY) {
  92                 if (perf_session__open(self, force) < 0)
  93                         goto out_delete;
  94         } else if (mode == O_WRONLY) {
  95                 /*
  96                  * In O_RDONLY mode this will be performed when reading the
  97                  * kernel MMAP event, in event__process_mmap().
  98                  */
  99                 if (perf_session__create_kernel_maps(self) < 0)
 100                         goto out_delete;
 101         }
 102
 103         perf_session__update_sample_type(self);
 104 out:
 105         return self;
 106 out_free:
 107         free(self);
 108         return NULL;
 109 out_delete:
 110         perf_session__delete(self);
 111         return NULL;
 112 }
 113
 114 void perf_session__delete(struct perf_session *self)
 115 {
 116         perf_header__exit(&self->header);
 117         close(self->fd);
 118         free(self->cwd);
 119         free(self);
 120 }
 121
 122 static bool symbol__match_parent_regex(struct symbol *sym)
 123 {
 124         if (sym->name && !regexec(&parent_regex, sym->name, 0, NULL, 0))
 125                 return 1;
 126
 127         return 0;
 128 }
 129
 130 struct map_symbol *perf_session__resolve_callchain(struct perf_session *self,
 131                                                    struct thread *thread,
 132                                                    struct ip_callchain *chain,
 133                                                    struct symbol **parent)
 134 {
 135         u8 cpumode = PERF_RECORD_MISC_USER;
 136         unsigned int i;
 137         struct map_symbol *syms = calloc(chain->nr, sizeof(*syms));
 138
 139         if (!syms)
 140                 return NULL;
 141
 142         for (i = 0; i < chain->nr; i++) {
 143                 u64 ip = chain->ips[i];
 144                 struct addr_location al;
 145
 146                 if (ip >= PERF_CONTEXT_MAX) {
 147                         switch (ip) {
 148                         case PERF_CONTEXT_HV:
 149                                 cpumode = PERF_RECORD_MISC_HYPERVISOR;  break;
 150                         case PERF_CONTEXT_KERNEL:
 151                                 cpumode = PERF_RECORD_MISC_KERNEL;      break;
 152                         case PERF_CONTEXT_USER:
 153                                 cpumode = PERF_RECORD_MISC_USER;        break;
 154                         default:
 155                                 break;
 156                         }
 157                         continue;
 158                 }
 159
 160                 thread__find_addr_location(thread, self, cpumode,
 161                                            MAP__FUNCTION, ip, &al, NULL);
 162                 if (al.sym != NULL) {
 163                         if (sort__has_parent && !*parent &&
 164                             symbol__match_parent_regex(al.sym))
 165                                 *parent = al.sym;
 166                         if (!symbol_conf.use_callchain)
 167                                 break;
 168                         syms[i].map = al.map;
 169                         syms[i].sym = al.sym;
 170                 }
 171         }
 172
 173         return syms;
 174 }
 175
 176 static int process_event_stub(event_t *event __used,
 177                               struct perf_session *session __used)
 178 {
 179         dump_printf(": unhandled!\n");
 180         return 0;
 181 }
 182
 183 static void perf_event_ops__fill_defaults(struct perf_event_ops *handler)
 184 {
 185         if (handler->sample == NULL)
 186                 handler->sample = process_event_stub;
 187         if (handler->mmap == NULL)
 188                 handler->mmap = process_event_stub;
 189         if (handler->comm == NULL)
 190                 handler->comm = process_event_stub;
 191         if (handler->fork == NULL)
 192                 handler->fork = process_event_stub;
 193         if (handler->exit == NULL)
 194                 handler->exit = process_event_stub;
 195         if (handler->lost == NULL)
 196                 handler->lost = process_event_stub;
 197         if (handler->read == NULL)
 198                 handler->read = process_event_stub;
 199         if (handler->throttle == NULL)
 200                 handler->throttle = process_event_stub;
 201         if (handler->unthrottle == NULL)
 202                 handler->unthrottle = process_event_stub;
 203         if (handler->attr == NULL)
 204                 handler->attr = process_event_stub;
 205         if (handler->event_type == NULL)
 206                 handler->event_type = process_event_stub;
 207         if (handler->tracing_data == NULL)
 208                 handler->tracing_data = process_event_stub;
 209         if (handler->build_id == NULL)
 210                 handler->build_id = process_event_stub;
 211 }
 212
 213 static const char *event__name[] = {
 214         [0]                      = "TOTAL",
 215         [PERF_RECORD_MMAP]       = "MMAP",
 216         [PERF_RECORD_LOST]       = "LOST",
 217         [PERF_RECORD_COMM]       = "COMM",
 218         [PERF_RECORD_EXIT]       = "EXIT",
 219         [PERF_RECORD_THROTTLE]   = "THROTTLE",
 220         [PERF_RECORD_UNTHROTTLE] = "UNTHROTTLE",
 221         [PERF_RECORD_FORK]       = "FORK",
 222         [PERF_RECORD_READ]       = "READ",
 223         [PERF_RECORD_SAMPLE]     = "SAMPLE",
 224         [PERF_RECORD_HEADER_ATTR]        = "ATTR",
 225         [PERF_RECORD_HEADER_EVENT_TYPE]  = "EVENT_TYPE",
 226         [PERF_RECORD_HEADER_TRACING_DATA]        = "TRACING_DATA",
 227         [PERF_RECORD_HEADER_BUILD_ID]    = "BUILD_ID",
 228 };
 229
 230 unsigned long event__total[PERF_RECORD_HEADER_MAX];
 231
 232 void event__print_totals(void)
 233 {
 234         int i;
 235         for (i = 0; i < PERF_RECORD_HEADER_MAX; ++i) {
 236                 if (!event__name[i])
 237                         continue;
 238                 pr_info("%10s events: %10ld\n",
 239                         event__name[i], event__total[i]);
 240         }
 241 }
 242
 243 void mem_bswap_64(void *src, int byte_size)
 244 {
 245         u64 *m = src;
 246
 247         while (byte_size > 0) {
 248                 *m = bswap_64(*m);
 249                 byte_size -= sizeof(u64);
 250                 ++m;
 251         }
 252 }
 253
 254 static void event__all64_swap(event_t *self)
 255 {
 256         struct perf_event_header *hdr = &self->header;
 257         mem_bswap_64(hdr + 1, self->header.size - sizeof(*hdr));
 258 }
 259
 260 static void event__comm_swap(event_t *self)
 261 {
 262         self->comm.pid = bswap_32(self->comm.pid);
 263         self->comm.tid = bswap_32(self->comm.tid);
 264 }
 265
 266 static void event__mmap_swap(event_t *self)
 267 {
 268         self->mmap.pid   = bswap_32(self->mmap.pid);
 269         self->mmap.tid   = bswap_32(self->mmap.tid);
 270         self->mmap.start = bswap_64(self->mmap.start);
 271         self->mmap.len   = bswap_64(self->mmap.len);
 272         self->mmap.pgoff = bswap_64(self->mmap.pgoff);
 273 }
 274
 275 static void event__task_swap(event_t *self)
 276 {
 277         self->fork.pid  = bswap_32(self->fork.pid);
 278         self->fork.tid  = bswap_32(self->fork.tid);
 279         self->fork.ppid = bswap_32(self->fork.ppid);
 280         self->fork.ptid = bswap_32(self->fork.ptid);
 281         self->fork.time = bswap_64(self->fork.time);
 282 }
 283
 284 static void event__read_swap(event_t *self)
 285 {
 286         self->read.pid          = bswap_32(self->read.pid);
 287         self->read.tid          = bswap_32(self->read.tid);
 288         self->read.value        = bswap_64(self->read.value);
 289         self->read.time_enabled = bswap_64(self->read.time_enabled);
 290         self->read.time_running = bswap_64(self->read.time_running);
 291         self->read.id           = bswap_64(self->read.id);
 292 }
 293
 294 static void event__attr_swap(event_t *self)
 295 {
 296         size_t size;
 297
 298         self->attr.attr.type            = bswap_32(self->attr.attr.type);
 299         self->attr.attr.size            = bswap_32(self->attr.attr.size);
 300         self->attr.attr.config          = bswap_64(self->attr.attr.config);
 301         self->attr.attr.sample_period   = bswap_64(self->attr.attr.sample_period);
 302         self->attr.attr.sample_type     = bswap_64(self->attr.attr.sample_type);
 303         self->attr.attr.read_format     = bswap_64(self->attr.attr.read_format);
 304         self->attr.attr.wakeup_events   = bswap_32(self->attr.attr.wakeup_events);
 305         self->attr.attr.bp_type         = bswap_32(self->attr.attr.bp_type);
 306         self->attr.attr.bp_addr         = bswap_64(self->attr.attr.bp_addr);
 307         self->attr.attr.bp_len          = bswap_64(self->attr.attr.bp_len);
 308
 309         size = self->header.size;
 310         size -= (void *)&self->attr.id - (void *)self;
 311         mem_bswap_64(self->attr.id, size);
 312 }
 313
 314 static void event__event_type_swap(event_t *self)
 315 {
 316         self->event_type.event_type.event_id =
 317                 bswap_64(self->event_type.event_type.event_id);
 318 }
 319
 320 static void event__tracing_data_swap(event_t *self)
 321 {
 322         self->tracing_data.size = bswap_32(self->tracing_data.size);
 323 }
 324
 325 typedef void (*event__swap_op)(event_t *self);
 326
 327 static event__swap_op event__swap_ops[] = {
 328         [PERF_RECORD_MMAP]   = event__mmap_swap,
 329         [PERF_RECORD_COMM]   = event__comm_swap,
 330         [PERF_RECORD_FORK]   = event__task_swap,
 331         [PERF_RECORD_EXIT]   = event__task_swap,
 332         [PERF_RECORD_LOST]   = event__all64_swap,
 333         [PERF_RECORD_READ]   = event__read_swap,
 334         [PERF_RECORD_SAMPLE] = event__all64_swap,
 335         [PERF_RECORD_HEADER_ATTR]   = event__attr_swap,
 336         [PERF_RECORD_HEADER_EVENT_TYPE]   = event__event_type_swap,
 337         [PERF_RECORD_HEADER_TRACING_DATA]   = event__tracing_data_swap,
 338         [PERF_RECORD_HEADER_BUILD_ID]   = NULL,
 339         [PERF_RECORD_HEADER_MAX]    = NULL,
 340 };
 341
 342 static int perf_session__process_event(struct perf_session *self,
 343                                        event_t *event,
 344                                        struct perf_event_ops *ops,
 345                                        u64 offset, u64 head)
 346 {
 347         trace_event(event);
 348
 349         if (event->header.type < PERF_RECORD_HEADER_MAX) {
 350                 dump_printf("%#Lx [%#x]: PERF_RECORD_%s",
 351                             offset + head, event->header.size,
 352                             event__name[event->header.type]);
 353                 ++event__total[0];
 354                 ++event__total[event->header.type];
 355         }
 356
 357         if (self->header.needs_swap && event__swap_ops[event->header.type])
 358                 event__swap_ops[event->header.type](event);
 359
 360         switch (event->header.type) {
 361         case PERF_RECORD_SAMPLE:
 362                 return ops->sample(event, self);
 363         case PERF_RECORD_MMAP:
 364                 return ops->mmap(event, self);
 365         case PERF_RECORD_COMM:
 366                 return ops->comm(event, self);
 367         case PERF_RECORD_FORK:
 368                 return ops->fork(event, self);
 369         case PERF_RECORD_EXIT:
 370                 return ops->exit(event, self);
 371         case PERF_RECORD_LOST:
 372                 return ops->lost(event, self);
 373         case PERF_RECORD_READ:
 374                 return ops->read(event, self);
 375         case PERF_RECORD_THROTTLE:
 376                 return ops->throttle(event, self);
 377         case PERF_RECORD_UNTHROTTLE:
 378                 return ops->unthrottle(event, self);
 379         case PERF_RECORD_HEADER_ATTR:
 380                 return ops->attr(event, self);
 381         case PERF_RECORD_HEADER_EVENT_TYPE:
 382                 return ops->event_type(event, self);
 383         case PERF_RECORD_HEADER_TRACING_DATA:
 384                 /* setup for reading amidst mmap */
 385                 lseek(self->fd, offset + head, SEEK_SET);
 386                 return ops->tracing_data(event, self);
 387         case PERF_RECORD_HEADER_BUILD_ID:
 388                 return ops->build_id(event, self);
 389         default:
 390                 self->unknown_events++;
 391                 return -1;
 392         }
 393 }
 394
 395 void perf_event_header__bswap(struct perf_event_header *self)
 396 {
 397         self->type = bswap_32(self->type);
 398         self->misc = bswap_16(self->misc);
 399         self->size = bswap_16(self->size);
 400 }
 401
 402 int perf_header__read_build_ids(struct perf_header *self,
 403                                 int input, u64 offset, u64 size)
 404 {
 405         struct build_id_event bev;
 406         char filename[PATH_MAX];
 407         u64 limit = offset + size;
 408         int err = -1;
 409
 410         while (offset < limit) {
 411                 struct dso *dso;
 412                 ssize_t len;
 413                 struct list_head *head = &dsos__user;
 414
 415                 if (read(input, &bev, sizeof(bev)) != sizeof(bev))
 416                         goto out;
 417
 418                 if (self->needs_swap)
 419                         perf_event_header__bswap(&bev.header);
 420
 421                 len = bev.header.size - sizeof(bev);
 422                 if (read(input, filename, len) != len)
 423                         goto out;
 424
 425                 if (bev.header.misc & PERF_RECORD_MISC_KERNEL)
 426                         head = &dsos__kernel;
 427
 428                 dso = __dsos__findnew(head, filename);
 429                 if (dso != NULL) {
 430                         dso__set_build_id(dso, &bev.build_id);
 431                         if (head == &dsos__kernel && filename[0] == '[')
 432                                 dso->kernel = 1;
 433                 }
 434
 435                 offset += bev.header.size;
 436         }
 437         err = 0;
 438 out:
 439         return err;
 440 }
 441
 442 static struct thread *perf_session__register_idle_thread(struct perf_session *self)
 443 {
 444         struct thread *thread = perf_session__findnew(self, 0);
 445
 446         if (thread == NULL || thread__set_comm(thread, "swapper")) {
 447                 pr_err("problem inserting idle task.\n");
 448                 thread = NULL;
 449         }
 450
 451         return thread;
 452 }
 453
 454 int do_read(int fd, void *buf, size_t size)
 455 {
 456         void *buf_start = buf;
 457
 458         while (size) {
 459                 int ret = read(fd, buf, size);
 460
 461                 if (ret <= 0)
 462                         return ret;
 463
 464                 size -= ret;
 465                 buf += ret;
 466         }
 467
 468         return buf - buf_start;
 469 }
 470
 471 #define session_done()  (*(volatile int *)(&session_done))
 472 volatile int session_done;
 473
 474 static int __perf_session__process_pipe_events(struct perf_session *self,
 475                                                struct perf_event_ops *ops)
 476 {
 477         event_t event;
 478         uint32_t size;
 479         int skip = 0;
 480         u64 head;
 481         int err;
 482         void *p;
 483
 484         perf_event_ops__fill_defaults(ops);
 485
 486         head = 0;
 487 more:
 488         err = do_read(self->fd, &event, sizeof(struct perf_event_header));
 489         if (err <= 0) {
 490                 if (err == 0)
 491                         goto done;
 492
 493                 pr_err("failed to read event header\n");
 494                 goto out_err;
 495         }
 496
 497         if (self->header.needs_swap)
 498                 perf_event_header__bswap(&event.header);
 499
 500         size = event.header.size;
 501         if (size == 0)
 502                 size = 8;
 503
 504         p = &event;
 505         p += sizeof(struct perf_event_header);
 506
 507         err = do_read(self->fd, p, size - sizeof(struct perf_event_header));
 508         if (err <= 0) {
 509                 if (err == 0) {
 510                         pr_err("unexpected end of event stream\n");
 511                         goto done;
 512                 }
 513
 514                 pr_err("failed to read event data\n");
 515                 goto out_err;
 516         }
 517
 518         if (size == 0 ||
 519             (skip = perf_session__process_event(self, &event, ops,
 520                                                 0, head)) < 0) {
 521                 dump_printf("%#Lx [%#x]: skipping unknown header type: %d\n",
 522                             head, event.header.size, event.header.type);
 523                 /*
 524                  * assume we lost track of the stream, check alignment, and
 525                  * increment a single u64 in the hope to catch on again 'soon'.
 526                  */
 527                 if (unlikely(head & 7))
 528                         head &= ~7ULL;
 529
 530                 size = 8;
 531         }
 532
 533         head += size;
 534
 535         dump_printf("\n%#Lx [%#x]: event: %d\n",
 536                     head, event.header.size, event.header.type);
 537
 538         if (skip > 0)
 539                 head += skip;
 540
 541         if (!session_done())
 542                 goto more;
 543 done:
 544         err = 0;
 545 out_err:
 546         return err;
 547 }
 548
 549 int __perf_session__process_events(struct perf_session *self,
 550                                    u64 data_offset, u64 data_size,
 551                                    u64 file_size, struct perf_event_ops *ops)
 552 {
 553         int err, mmap_prot, mmap_flags;
 554         u64 head, shift;
 555         u64 offset = 0;
 556         size_t  page_size;
 557         event_t *event;
 558         uint32_t size;
 559         char *buf;
 560         struct ui_progress *progress = ui_progress__new("Processing events...",
 561                                                         self->size);
 562         if (progress == NULL)
 563                 return -1;
 564
 565         perf_event_ops__fill_defaults(ops);
 566
 567         page_size = sysconf(_SC_PAGESIZE);
 568
 569         head = data_offset;
 570         shift = page_size * (head / page_size);
 571         offset += shift;
 572         head -= shift;
 573
 574         mmap_prot  = PROT_READ;
 575         mmap_flags = MAP_SHARED;
 576
 577         if (self->header.needs_swap) {
 578                 mmap_prot  |= PROT_WRITE;
 579                 mmap_flags = MAP_PRIVATE;
 580         }
 581 remap:
 582         buf = mmap(NULL, page_size * self->mmap_window, mmap_prot,
 583                    mmap_flags, self->fd, offset);
 584         if (buf == MAP_FAILED) {
 585                 pr_err("failed to mmap file\n");
 586                 err = -errno;
 587                 goto out_err;
 588         }
 589
 590 more:
 591         event = (event_t *)(buf + head);
 592         ui_progress__update(progress, offset);
 593
 594         if (self->header.needs_swap)
 595                 perf_event_header__bswap(&event->header);
 596         size = event->header.size;
 597         if (size == 0)
 598                 size = 8;
 599
 600         if (head + event->header.size >= page_size * self->mmap_window) {
 601                 int munmap_ret;
 602
 603                 shift = page_size * (head / page_size);
 604
 605                 munmap_ret = munmap(buf, page_size * self->mmap_window);
 606                 assert(munmap_ret == 0);
 607
 608                 offset += shift;
 609                 head -= shift;
 610                 goto remap;
 611         }
 612
 613         size = event->header.size;
 614
 615         dump_printf("\n%#Lx [%#x]: event: %d\n",
 616                     offset + head, event->header.size, event->header.type);
 617
 618         if (size == 0 ||
 619             perf_session__process_event(self, event, ops, offset, head) < 0) {
 620                 dump_printf("%#Lx [%#x]: skipping unknown header type: %d\n",
 621                             offset + head, event->header.size,
 622                             event->header.type);
 623                 /*
 624                  * assume we lost track of the stream, check alignment, and
 625                  * increment a single u64 in the hope to catch on again 'soon'.
 626                  */
 627                 if (unlikely(head & 7))
 628                         head &= ~7ULL;
 629
 630                 size = 8;
 631         }
 632
 633         head += size;
 634
 635         if (offset + head >= data_offset + data_size)
 636                 goto done;
 637
 638         if (offset + head < file_size)
 639                 goto more;
 640 done:
 641         err = 0;
 642 out_err:
 643         ui_progress__delete(progress);
 644         return err;
 645 }
 646
 647 int perf_session__process_events(struct perf_session *self,
 648                                  struct perf_event_ops *ops)
 649 {
 650         int err;
 651
 652         if (perf_session__register_idle_thread(self) == NULL)
 653                 return -ENOMEM;
 654
 655         if (!symbol_conf.full_paths) {
 656                 char bf[PATH_MAX];
 657
 658                 if (getcwd(bf, sizeof(bf)) == NULL) {
 659                         err = -errno;
 660 out_getcwd_err:
 661                         pr_err("failed to get the current directory\n");
 662                         goto out_err;
 663                 }
 664                 self->cwd = strdup(bf);
 665                 if (self->cwd == NULL) {
 666                         err = -ENOMEM;
 667                         goto out_getcwd_err;
 668                 }
 669                 self->cwdlen = strlen(self->cwd);
 670         }
 671
 672         if (!self->fd_pipe)
 673                 err = __perf_session__process_events(self,
 674                                                      self->header.data_offset,
 675                                                      self->header.data_size,
 676                                                      self->size, ops);
 677         else
 678                 err = __perf_session__process_pipe_events(self, ops);
 679 out_err:
 680         return err;
 681 }
 682
 683 bool perf_session__has_traces(struct perf_session *self, const char *msg)
 684 {
 685         if (!(self->sample_type & PERF_SAMPLE_RAW)) {
 686                 pr_err("No trace sample to read. Did you call 'perf %s'?\n", msg);
 687                 return false;
 688         }
 689
 690         return true;
 691 }
 692
 693 int perf_session__set_kallsyms_ref_reloc_sym(struct perf_session *self,
 694                                              const char *symbol_name,
 695                                              u64 addr)
 696 {
 697         char *bracket;
 698         enum map_type i;
 699
 700         self->ref_reloc_sym.name = strdup(symbol_name);
 701         if (self->ref_reloc_sym.name == NULL)
 702                 return -ENOMEM;
 703
 704         bracket = strchr(self->ref_reloc_sym.name, ']');
 705         if (bracket)
 706                 *bracket = '\0';
 707
 708         self->ref_reloc_sym.addr = addr;
 709
 710         for (i = 0; i < MAP__NR_TYPES; ++i) {
 711                 struct kmap *kmap = map__kmap(self->vmlinux_maps[i]);
 712                 kmap->ref_reloc_sym = &self->ref_reloc_sym;
 713         }
 714
 715         return 0;
 716 }