session.c 22 KB

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