tools/perf/util/data_map.c

   1 #include "data_map.h"
   2 #include "symbol.h"
   3 #include "util.h"
   4 #include "debug.h"
   5
   6
   7 static struct perf_file_handler *curr_handler;
   8 static unsigned long    mmap_window = 32;
   9 static char             __cwd[PATH_MAX];
  10
  11 static int
  12 process_event_stub(event_t *event __used,
  13                    unsigned long offset __used,
  14                    unsigned long head __used)
  15 {
  16         return 0;
  17 }
  18
  19 void register_perf_file_handler(struct perf_file_handler *handler)
  20 {
  21         if (!handler->process_sample_event)
  22                 handler->process_sample_event = process_event_stub;
  23         if (!handler->process_mmap_event)
  24                 handler->process_mmap_event = process_event_stub;
  25         if (!handler->process_comm_event)
  26                 handler->process_comm_event = process_event_stub;
  27         if (!handler->process_fork_event)
  28                 handler->process_fork_event = process_event_stub;
  29         if (!handler->process_exit_event)
  30                 handler->process_exit_event = process_event_stub;
  31         if (!handler->process_lost_event)
  32                 handler->process_lost_event = process_event_stub;
  33         if (!handler->process_read_event)
  34                 handler->process_read_event = process_event_stub;
  35         if (!handler->process_throttle_event)
  36                 handler->process_throttle_event = process_event_stub;
  37         if (!handler->process_unthrottle_event)
  38                 handler->process_unthrottle_event = process_event_stub;
  39
  40         curr_handler = handler;
  41 }
  42
  43 static int
  44 process_event(event_t *event, unsigned long offset, unsigned long head)
  45 {
  46         trace_event(event);
  47
  48         switch (event->header.type) {
  49         case PERF_RECORD_SAMPLE:
  50                 return curr_handler->process_sample_event(event, offset, head);
  51         case PERF_RECORD_MMAP:
  52                 return curr_handler->process_mmap_event(event, offset, head);
  53         case PERF_RECORD_COMM:
  54                 return curr_handler->process_comm_event(event, offset, head);
  55         case PERF_RECORD_FORK:
  56                 return curr_handler->process_fork_event(event, offset, head);
  57         case PERF_RECORD_EXIT:
  58                 return curr_handler->process_exit_event(event, offset, head);
  59         case PERF_RECORD_LOST:
  60                 return curr_handler->process_lost_event(event, offset, head);
  61         case PERF_RECORD_READ:
  62                 return curr_handler->process_read_event(event, offset, head);
  63         case PERF_RECORD_THROTTLE:
  64                 return curr_handler->process_throttle_event(event, offset, head);
  65         case PERF_RECORD_UNTHROTTLE:
  66                 return curr_handler->process_unthrottle_event(event, offset, head);
  67         default:
  68                 curr_handler->total_unknown++;
  69                 return -1;
  70         }
  71 }
  72
  73 int perf_header__read_build_ids(int input, off_t offset, off_t size)
  74 {
  75         struct build_id_event bev;
  76         char filename[PATH_MAX];
  77         off_t limit = offset + size;
  78         int err = -1;
  79
  80         while (offset < limit) {
  81                 struct dso *dso;
  82                 ssize_t len;
  83
  84                 if (read(input, &bev, sizeof(bev)) != sizeof(bev))
  85                         goto out;
  86
  87                 len = bev.header.size - sizeof(bev);
  88                 if (read(input, filename, len) != len)
  89                         goto out;
  90
  91                 dso = dsos__findnew(filename);
  92                 if (dso != NULL)
  93                         dso__set_build_id(dso, &bev.build_id);
  94
  95                 offset += bev.header.size;
  96         }
  97         err = 0;
  98 out:
  99         return err;
 100 }
 101
 102 int mmap_dispatch_perf_file(struct perf_header **pheader,
 103                             const char *input_name,
 104                             int force,
 105                             int full_paths,
 106                             int *cwdlen,
 107                             char **cwd)
 108 {
 109         int err;
 110         struct perf_header *header;
 111         unsigned long head, shift;
 112         unsigned long offset = 0;
 113         struct stat input_stat;
 114         size_t  page_size;
 115         u64 sample_type;
 116         event_t *event;
 117         uint32_t size;
 118         int input;
 119         char *buf;
 120
 121         if (curr_handler == NULL) {
 122                 pr_debug("Forgot to register perf file handler\n");
 123                 return -EINVAL;
 124         }
 125
 126         page_size = getpagesize();
 127
 128         input = open(input_name, O_RDONLY);
 129         if (input < 0) {
 130                 pr_err("Failed to open file: %s", input_name);
 131                 if (!strcmp(input_name, "perf.data"))
 132                         pr_err("  (try 'perf record' first)");
 133                 pr_err("\n");
 134                 return -errno;
 135         }
 136
 137         if (fstat(input, &input_stat) < 0) {
 138                 pr_err("failed to stat file");
 139                 err = -errno;
 140                 goto out_close;
 141         }
 142
 143         err = -EACCES;
 144         if (!force && input_stat.st_uid && (input_stat.st_uid != geteuid())) {
 145                 pr_err("file: %s not owned by current user or root\n",
 146                         input_name);
 147                 goto out_close;
 148         }
 149
 150         if (input_stat.st_size == 0) {
 151                 pr_info("zero-sized file, nothing to do!\n");
 152                 goto done;
 153         }
 154
 155         err = -ENOMEM;
 156         header = perf_header__new();
 157         if (header == NULL)
 158                 goto out_close;
 159
 160         err = perf_header__read(header, input);
 161         if (err < 0)
 162                 goto out_delete;
 163         *pheader = header;
 164         head = header->data_offset;
 165
 166         sample_type = perf_header__sample_type(header);
 167
 168         err = -EINVAL;
 169         if (curr_handler->sample_type_check &&
 170             curr_handler->sample_type_check(sample_type) < 0)
 171                 goto out_delete;
 172
 173         err = -ENOMEM;
 174         if (kernel_maps__init(true) < 0) {
 175                 pr_err("failed to setup the kernel maps to resolve symbols\n");
 176                 goto out_delete;
 177         }
 178
 179         if (!full_paths) {
 180                 if (getcwd(__cwd, sizeof(__cwd)) == NULL) {
 181                         pr_err("failed to get the current directory\n");
 182                         err = -errno;
 183                         goto out_delete;
 184                 }
 185                 *cwd = __cwd;
 186                 *cwdlen = strlen(*cwd);
 187         } else {
 188                 *cwd = NULL;
 189                 *cwdlen = 0;
 190         }
 191
 192         shift = page_size * (head / page_size);
 193         offset += shift;
 194         head -= shift;
 195
 196 remap:
 197         buf = mmap(NULL, page_size * mmap_window, PROT_READ,
 198                    MAP_SHARED, input, offset);
 199         if (buf == MAP_FAILED) {
 200                 pr_err("failed to mmap file\n");
 201                 err = -errno;
 202                 goto out_delete;
 203         }
 204
 205 more:
 206         event = (event_t *)(buf + head);
 207
 208         size = event->header.size;
 209         if (!size)
 210                 size = 8;
 211
 212         if (head + event->header.size >= page_size * mmap_window) {
 213                 int munmap_ret;
 214
 215                 shift = page_size * (head / page_size);
 216
 217                 munmap_ret = munmap(buf, page_size * mmap_window);
 218                 assert(munmap_ret == 0);
 219
 220                 offset += shift;
 221                 head -= shift;
 222                 goto remap;
 223         }
 224
 225         size = event->header.size;
 226
 227         dump_printf("\n%p [%p]: event: %d\n",
 228                         (void *)(offset + head),
 229                         (void *)(long)event->header.size,
 230                         event->header.type);
 231
 232         if (!size || process_event(event, offset, head) < 0) {
 233
 234                 dump_printf("%p [%p]: skipping unknown header type: %d\n",
 235                         (void *)(offset + head),
 236                         (void *)(long)(event->header.size),
 237                         event->header.type);
 238
 239                 /*
 240                  * assume we lost track of the stream, check alignment, and
 241                  * increment a single u64 in the hope to catch on again 'soon'.
 242                  */
 243
 244                 if (unlikely(head & 7))
 245                         head &= ~7ULL;
 246
 247                 size = 8;
 248         }
 249
 250         head += size;
 251
 252         if (offset + head >= header->data_offset + header->data_size)
 253                 goto done;
 254
 255         if (offset + head < (unsigned long)input_stat.st_size)
 256                 goto more;
 257
 258 done:
 259         err = 0;
 260 out_close:
 261         close(input);
 262
 263         return err;
 264 out_delete:
 265         perf_header__delete(header);
 266         goto out_close;
 267 }