session.c 29 KB

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117111811191120112111221123112411251126112711281129113011311132113311341135113611371138113911401141114211431144114511461147
  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 <sys/mman.h>
  7. #include "session.h"
  8. #include "sort.h"
  9. #include "util.h"
  10. static int perf_session__open(struct perf_session *self, bool force)
  11. {
  12. struct stat input_stat;
  13. if (!strcmp(self->filename, "-")) {
  14. self->fd_pipe = true;
  15. self->fd = STDIN_FILENO;
  16. if (perf_header__read(self, self->fd) < 0)
  17. pr_err("incompatible file format");
  18. return 0;
  19. }
  20. self->fd = open(self->filename, O_RDONLY);
  21. if (self->fd < 0) {
  22. int err = errno;
  23. pr_err("failed to open %s: %s", self->filename, strerror(err));
  24. if (err == ENOENT && !strcmp(self->filename, "perf.data"))
  25. pr_err(" (try 'perf record' first)");
  26. pr_err("\n");
  27. return -errno;
  28. }
  29. if (fstat(self->fd, &input_stat) < 0)
  30. goto out_close;
  31. if (!force && input_stat.st_uid && (input_stat.st_uid != geteuid())) {
  32. pr_err("file %s not owned by current user or root\n",
  33. self->filename);
  34. goto out_close;
  35. }
  36. if (!input_stat.st_size) {
  37. pr_info("zero-sized file (%s), nothing to do!\n",
  38. self->filename);
  39. goto out_close;
  40. }
  41. if (perf_header__read(self, self->fd) < 0) {
  42. pr_err("incompatible file format");
  43. goto out_close;
  44. }
  45. self->size = input_stat.st_size;
  46. return 0;
  47. out_close:
  48. close(self->fd);
  49. self->fd = -1;
  50. return -1;
  51. }
  52. static void perf_session__id_header_size(struct perf_session *session)
  53. {
  54. struct sample_data *data;
  55. u64 sample_type = session->sample_type;
  56. u16 size = 0;
  57. if (!session->sample_id_all)
  58. goto out;
  59. if (sample_type & PERF_SAMPLE_TID)
  60. size += sizeof(data->tid) * 2;
  61. if (sample_type & PERF_SAMPLE_TIME)
  62. size += sizeof(data->time);
  63. if (sample_type & PERF_SAMPLE_ID)
  64. size += sizeof(data->id);
  65. if (sample_type & PERF_SAMPLE_STREAM_ID)
  66. size += sizeof(data->stream_id);
  67. if (sample_type & PERF_SAMPLE_CPU)
  68. size += sizeof(data->cpu) * 2;
  69. out:
  70. session->id_hdr_size = size;
  71. }
  72. void perf_session__set_sample_id_all(struct perf_session *session, bool value)
  73. {
  74. session->sample_id_all = value;
  75. perf_session__id_header_size(session);
  76. }
  77. void perf_session__set_sample_type(struct perf_session *session, u64 type)
  78. {
  79. session->sample_type = type;
  80. }
  81. void perf_session__update_sample_type(struct perf_session *self)
  82. {
  83. self->sample_type = perf_header__sample_type(&self->header);
  84. self->sample_id_all = perf_header__sample_id_all(&self->header);
  85. perf_session__id_header_size(self);
  86. }
  87. int perf_session__create_kernel_maps(struct perf_session *self)
  88. {
  89. int ret = machine__create_kernel_maps(&self->host_machine);
  90. if (ret >= 0)
  91. ret = machines__create_guest_kernel_maps(&self->machines);
  92. return ret;
  93. }
  94. static void perf_session__destroy_kernel_maps(struct perf_session *self)
  95. {
  96. machine__destroy_kernel_maps(&self->host_machine);
  97. machines__destroy_guest_kernel_maps(&self->machines);
  98. }
  99. struct perf_session *perf_session__new(const char *filename, int mode,
  100. bool force, bool repipe,
  101. struct perf_event_ops *ops)
  102. {
  103. size_t len = filename ? strlen(filename) + 1 : 0;
  104. struct perf_session *self = zalloc(sizeof(*self) + len);
  105. if (self == NULL)
  106. goto out;
  107. if (perf_header__init(&self->header) < 0)
  108. goto out_free;
  109. memcpy(self->filename, filename, len);
  110. self->threads = RB_ROOT;
  111. INIT_LIST_HEAD(&self->dead_threads);
  112. self->hists_tree = RB_ROOT;
  113. self->last_match = NULL;
  114. /*
  115. * On 64bit we can mmap the data file in one go. No need for tiny mmap
  116. * slices. On 32bit we use 32MB.
  117. */
  118. #if BITS_PER_LONG == 64
  119. self->mmap_window = ULLONG_MAX;
  120. #else
  121. self->mmap_window = 32 * 1024 * 1024ULL;
  122. #endif
  123. self->machines = RB_ROOT;
  124. self->repipe = repipe;
  125. INIT_LIST_HEAD(&self->ordered_samples.samples);
  126. INIT_LIST_HEAD(&self->ordered_samples.sample_cache);
  127. INIT_LIST_HEAD(&self->ordered_samples.to_free);
  128. machine__init(&self->host_machine, "", HOST_KERNEL_ID);
  129. if (mode == O_RDONLY) {
  130. if (perf_session__open(self, force) < 0)
  131. goto out_delete;
  132. } else if (mode == O_WRONLY) {
  133. /*
  134. * In O_RDONLY mode this will be performed when reading the
  135. * kernel MMAP event, in event__process_mmap().
  136. */
  137. if (perf_session__create_kernel_maps(self) < 0)
  138. goto out_delete;
  139. }
  140. perf_session__update_sample_type(self);
  141. if (ops && ops->ordering_requires_timestamps &&
  142. ops->ordered_samples && !self->sample_id_all) {
  143. dump_printf("WARNING: No sample_id_all support, falling back to unordered processing\n");
  144. ops->ordered_samples = false;
  145. }
  146. out:
  147. return self;
  148. out_free:
  149. free(self);
  150. return NULL;
  151. out_delete:
  152. perf_session__delete(self);
  153. return NULL;
  154. }
  155. static void perf_session__delete_dead_threads(struct perf_session *self)
  156. {
  157. struct thread *n, *t;
  158. list_for_each_entry_safe(t, n, &self->dead_threads, node) {
  159. list_del(&t->node);
  160. thread__delete(t);
  161. }
  162. }
  163. static void perf_session__delete_threads(struct perf_session *self)
  164. {
  165. struct rb_node *nd = rb_first(&self->threads);
  166. while (nd) {
  167. struct thread *t = rb_entry(nd, struct thread, rb_node);
  168. rb_erase(&t->rb_node, &self->threads);
  169. nd = rb_next(nd);
  170. thread__delete(t);
  171. }
  172. }
  173. void perf_session__delete(struct perf_session *self)
  174. {
  175. perf_header__exit(&self->header);
  176. perf_session__destroy_kernel_maps(self);
  177. perf_session__delete_dead_threads(self);
  178. perf_session__delete_threads(self);
  179. machine__exit(&self->host_machine);
  180. close(self->fd);
  181. free(self);
  182. }
  183. void perf_session__remove_thread(struct perf_session *self, struct thread *th)
  184. {
  185. self->last_match = NULL;
  186. rb_erase(&th->rb_node, &self->threads);
  187. /*
  188. * We may have references to this thread, for instance in some hist_entry
  189. * instances, so just move them to a separate list.
  190. */
  191. list_add_tail(&th->node, &self->dead_threads);
  192. }
  193. static bool symbol__match_parent_regex(struct symbol *sym)
  194. {
  195. if (sym->name && !regexec(&parent_regex, sym->name, 0, NULL, 0))
  196. return 1;
  197. return 0;
  198. }
  199. struct map_symbol *perf_session__resolve_callchain(struct perf_session *self,
  200. struct thread *thread,
  201. struct ip_callchain *chain,
  202. struct symbol **parent)
  203. {
  204. u8 cpumode = PERF_RECORD_MISC_USER;
  205. unsigned int i;
  206. struct map_symbol *syms = calloc(chain->nr, sizeof(*syms));
  207. if (!syms)
  208. return NULL;
  209. for (i = 0; i < chain->nr; i++) {
  210. u64 ip = chain->ips[i];
  211. struct addr_location al;
  212. if (ip >= PERF_CONTEXT_MAX) {
  213. switch (ip) {
  214. case PERF_CONTEXT_HV:
  215. cpumode = PERF_RECORD_MISC_HYPERVISOR; break;
  216. case PERF_CONTEXT_KERNEL:
  217. cpumode = PERF_RECORD_MISC_KERNEL; break;
  218. case PERF_CONTEXT_USER:
  219. cpumode = PERF_RECORD_MISC_USER; break;
  220. default:
  221. break;
  222. }
  223. continue;
  224. }
  225. al.filtered = false;
  226. thread__find_addr_location(thread, self, cpumode,
  227. MAP__FUNCTION, thread->pid, ip, &al, NULL);
  228. if (al.sym != NULL) {
  229. if (sort__has_parent && !*parent &&
  230. symbol__match_parent_regex(al.sym))
  231. *parent = al.sym;
  232. if (!symbol_conf.use_callchain)
  233. break;
  234. syms[i].map = al.map;
  235. syms[i].sym = al.sym;
  236. }
  237. }
  238. return syms;
  239. }
  240. static int process_event_synth_stub(event_t *event __used,
  241. struct perf_session *session __used)
  242. {
  243. dump_printf(": unhandled!\n");
  244. return 0;
  245. }
  246. static int process_event_stub(event_t *event __used,
  247. struct sample_data *sample __used,
  248. struct perf_session *session __used)
  249. {
  250. dump_printf(": unhandled!\n");
  251. return 0;
  252. }
  253. static int process_finished_round_stub(event_t *event __used,
  254. struct perf_session *session __used,
  255. struct perf_event_ops *ops __used)
  256. {
  257. dump_printf(": unhandled!\n");
  258. return 0;
  259. }
  260. static int process_finished_round(event_t *event,
  261. struct perf_session *session,
  262. struct perf_event_ops *ops);
  263. static void perf_event_ops__fill_defaults(struct perf_event_ops *handler)
  264. {
  265. if (handler->sample == NULL)
  266. handler->sample = process_event_stub;
  267. if (handler->mmap == NULL)
  268. handler->mmap = process_event_stub;
  269. if (handler->comm == NULL)
  270. handler->comm = process_event_stub;
  271. if (handler->fork == NULL)
  272. handler->fork = process_event_stub;
  273. if (handler->exit == NULL)
  274. handler->exit = process_event_stub;
  275. if (handler->lost == NULL)
  276. handler->lost = event__process_lost;
  277. if (handler->read == NULL)
  278. handler->read = process_event_stub;
  279. if (handler->throttle == NULL)
  280. handler->throttle = process_event_stub;
  281. if (handler->unthrottle == NULL)
  282. handler->unthrottle = process_event_stub;
  283. if (handler->attr == NULL)
  284. handler->attr = process_event_synth_stub;
  285. if (handler->event_type == NULL)
  286. handler->event_type = process_event_synth_stub;
  287. if (handler->tracing_data == NULL)
  288. handler->tracing_data = process_event_synth_stub;
  289. if (handler->build_id == NULL)
  290. handler->build_id = process_event_synth_stub;
  291. if (handler->finished_round == NULL) {
  292. if (handler->ordered_samples)
  293. handler->finished_round = process_finished_round;
  294. else
  295. handler->finished_round = process_finished_round_stub;
  296. }
  297. }
  298. void mem_bswap_64(void *src, int byte_size)
  299. {
  300. u64 *m = src;
  301. while (byte_size > 0) {
  302. *m = bswap_64(*m);
  303. byte_size -= sizeof(u64);
  304. ++m;
  305. }
  306. }
  307. static void event__all64_swap(event_t *self)
  308. {
  309. struct perf_event_header *hdr = &self->header;
  310. mem_bswap_64(hdr + 1, self->header.size - sizeof(*hdr));
  311. }
  312. static void event__comm_swap(event_t *self)
  313. {
  314. self->comm.pid = bswap_32(self->comm.pid);
  315. self->comm.tid = bswap_32(self->comm.tid);
  316. }
  317. static void event__mmap_swap(event_t *self)
  318. {
  319. self->mmap.pid = bswap_32(self->mmap.pid);
  320. self->mmap.tid = bswap_32(self->mmap.tid);
  321. self->mmap.start = bswap_64(self->mmap.start);
  322. self->mmap.len = bswap_64(self->mmap.len);
  323. self->mmap.pgoff = bswap_64(self->mmap.pgoff);
  324. }
  325. static void event__task_swap(event_t *self)
  326. {
  327. self->fork.pid = bswap_32(self->fork.pid);
  328. self->fork.tid = bswap_32(self->fork.tid);
  329. self->fork.ppid = bswap_32(self->fork.ppid);
  330. self->fork.ptid = bswap_32(self->fork.ptid);
  331. self->fork.time = bswap_64(self->fork.time);
  332. }
  333. static void event__read_swap(event_t *self)
  334. {
  335. self->read.pid = bswap_32(self->read.pid);
  336. self->read.tid = bswap_32(self->read.tid);
  337. self->read.value = bswap_64(self->read.value);
  338. self->read.time_enabled = bswap_64(self->read.time_enabled);
  339. self->read.time_running = bswap_64(self->read.time_running);
  340. self->read.id = bswap_64(self->read.id);
  341. }
  342. static void event__attr_swap(event_t *self)
  343. {
  344. size_t size;
  345. self->attr.attr.type = bswap_32(self->attr.attr.type);
  346. self->attr.attr.size = bswap_32(self->attr.attr.size);
  347. self->attr.attr.config = bswap_64(self->attr.attr.config);
  348. self->attr.attr.sample_period = bswap_64(self->attr.attr.sample_period);
  349. self->attr.attr.sample_type = bswap_64(self->attr.attr.sample_type);
  350. self->attr.attr.read_format = bswap_64(self->attr.attr.read_format);
  351. self->attr.attr.wakeup_events = bswap_32(self->attr.attr.wakeup_events);
  352. self->attr.attr.bp_type = bswap_32(self->attr.attr.bp_type);
  353. self->attr.attr.bp_addr = bswap_64(self->attr.attr.bp_addr);
  354. self->attr.attr.bp_len = bswap_64(self->attr.attr.bp_len);
  355. size = self->header.size;
  356. size -= (void *)&self->attr.id - (void *)self;
  357. mem_bswap_64(self->attr.id, size);
  358. }
  359. static void event__event_type_swap(event_t *self)
  360. {
  361. self->event_type.event_type.event_id =
  362. bswap_64(self->event_type.event_type.event_id);
  363. }
  364. static void event__tracing_data_swap(event_t *self)
  365. {
  366. self->tracing_data.size = bswap_32(self->tracing_data.size);
  367. }
  368. typedef void (*event__swap_op)(event_t *self);
  369. static event__swap_op event__swap_ops[] = {
  370. [PERF_RECORD_MMAP] = event__mmap_swap,
  371. [PERF_RECORD_COMM] = event__comm_swap,
  372. [PERF_RECORD_FORK] = event__task_swap,
  373. [PERF_RECORD_EXIT] = event__task_swap,
  374. [PERF_RECORD_LOST] = event__all64_swap,
  375. [PERF_RECORD_READ] = event__read_swap,
  376. [PERF_RECORD_SAMPLE] = event__all64_swap,
  377. [PERF_RECORD_HEADER_ATTR] = event__attr_swap,
  378. [PERF_RECORD_HEADER_EVENT_TYPE] = event__event_type_swap,
  379. [PERF_RECORD_HEADER_TRACING_DATA] = event__tracing_data_swap,
  380. [PERF_RECORD_HEADER_BUILD_ID] = NULL,
  381. [PERF_RECORD_HEADER_MAX] = NULL,
  382. };
  383. struct sample_queue {
  384. u64 timestamp;
  385. u64 file_offset;
  386. event_t *event;
  387. struct list_head list;
  388. };
  389. static void perf_session_free_sample_buffers(struct perf_session *session)
  390. {
  391. struct ordered_samples *os = &session->ordered_samples;
  392. while (!list_empty(&os->to_free)) {
  393. struct sample_queue *sq;
  394. sq = list_entry(os->to_free.next, struct sample_queue, list);
  395. list_del(&sq->list);
  396. free(sq);
  397. }
  398. }
  399. static int perf_session_deliver_event(struct perf_session *session,
  400. event_t *event,
  401. struct sample_data *sample,
  402. struct perf_event_ops *ops,
  403. u64 file_offset);
  404. static void flush_sample_queue(struct perf_session *s,
  405. struct perf_event_ops *ops)
  406. {
  407. struct ordered_samples *os = &s->ordered_samples;
  408. struct list_head *head = &os->samples;
  409. struct sample_queue *tmp, *iter;
  410. struct sample_data sample;
  411. u64 limit = os->next_flush;
  412. u64 last_ts = os->last_sample ? os->last_sample->timestamp : 0ULL;
  413. if (!ops->ordered_samples || !limit)
  414. return;
  415. list_for_each_entry_safe(iter, tmp, head, list) {
  416. if (iter->timestamp > limit)
  417. break;
  418. event__parse_sample(iter->event, s, &sample);
  419. perf_session_deliver_event(s, iter->event, &sample, ops,
  420. iter->file_offset);
  421. os->last_flush = iter->timestamp;
  422. list_del(&iter->list);
  423. list_add(&iter->list, &os->sample_cache);
  424. }
  425. if (list_empty(head)) {
  426. os->last_sample = NULL;
  427. } else if (last_ts <= limit) {
  428. os->last_sample =
  429. list_entry(head->prev, struct sample_queue, list);
  430. }
  431. }
  432. /*
  433. * When perf record finishes a pass on every buffers, it records this pseudo
  434. * event.
  435. * We record the max timestamp t found in the pass n.
  436. * Assuming these timestamps are monotonic across cpus, we know that if
  437. * a buffer still has events with timestamps below t, they will be all
  438. * available and then read in the pass n + 1.
  439. * Hence when we start to read the pass n + 2, we can safely flush every
  440. * events with timestamps below t.
  441. *
  442. * ============ PASS n =================
  443. * CPU 0 | CPU 1
  444. * |
  445. * cnt1 timestamps | cnt2 timestamps
  446. * 1 | 2
  447. * 2 | 3
  448. * - | 4 <--- max recorded
  449. *
  450. * ============ PASS n + 1 ==============
  451. * CPU 0 | CPU 1
  452. * |
  453. * cnt1 timestamps | cnt2 timestamps
  454. * 3 | 5
  455. * 4 | 6
  456. * 5 | 7 <---- max recorded
  457. *
  458. * Flush every events below timestamp 4
  459. *
  460. * ============ PASS n + 2 ==============
  461. * CPU 0 | CPU 1
  462. * |
  463. * cnt1 timestamps | cnt2 timestamps
  464. * 6 | 8
  465. * 7 | 9
  466. * - | 10
  467. *
  468. * Flush every events below timestamp 7
  469. * etc...
  470. */
  471. static int process_finished_round(event_t *event __used,
  472. struct perf_session *session,
  473. struct perf_event_ops *ops)
  474. {
  475. flush_sample_queue(session, ops);
  476. session->ordered_samples.next_flush = session->ordered_samples.max_timestamp;
  477. return 0;
  478. }
  479. /* The queue is ordered by time */
  480. static void __queue_event(struct sample_queue *new, struct perf_session *s)
  481. {
  482. struct ordered_samples *os = &s->ordered_samples;
  483. struct sample_queue *sample = os->last_sample;
  484. u64 timestamp = new->timestamp;
  485. struct list_head *p;
  486. os->last_sample = new;
  487. if (!sample) {
  488. list_add(&new->list, &os->samples);
  489. os->max_timestamp = timestamp;
  490. return;
  491. }
  492. /*
  493. * last_sample might point to some random place in the list as it's
  494. * the last queued event. We expect that the new event is close to
  495. * this.
  496. */
  497. if (sample->timestamp <= timestamp) {
  498. while (sample->timestamp <= timestamp) {
  499. p = sample->list.next;
  500. if (p == &os->samples) {
  501. list_add_tail(&new->list, &os->samples);
  502. os->max_timestamp = timestamp;
  503. return;
  504. }
  505. sample = list_entry(p, struct sample_queue, list);
  506. }
  507. list_add_tail(&new->list, &sample->list);
  508. } else {
  509. while (sample->timestamp > timestamp) {
  510. p = sample->list.prev;
  511. if (p == &os->samples) {
  512. list_add(&new->list, &os->samples);
  513. return;
  514. }
  515. sample = list_entry(p, struct sample_queue, list);
  516. }
  517. list_add(&new->list, &sample->list);
  518. }
  519. }
  520. #define MAX_SAMPLE_BUFFER (64 * 1024 / sizeof(struct sample_queue))
  521. static int perf_session_queue_event(struct perf_session *s, event_t *event,
  522. struct sample_data *data, u64 file_offset)
  523. {
  524. struct ordered_samples *os = &s->ordered_samples;
  525. struct list_head *sc = &os->sample_cache;
  526. u64 timestamp = data->time;
  527. struct sample_queue *new;
  528. if (!timestamp || timestamp == ~0ULL)
  529. return -ETIME;
  530. if (timestamp < s->ordered_samples.last_flush) {
  531. printf("Warning: Timestamp below last timeslice flush\n");
  532. return -EINVAL;
  533. }
  534. if (!list_empty(sc)) {
  535. new = list_entry(sc->next, struct sample_queue, list);
  536. list_del(&new->list);
  537. } else if (os->sample_buffer) {
  538. new = os->sample_buffer + os->sample_buffer_idx;
  539. if (++os->sample_buffer_idx == MAX_SAMPLE_BUFFER)
  540. os->sample_buffer = NULL;
  541. } else {
  542. os->sample_buffer = malloc(MAX_SAMPLE_BUFFER * sizeof(*new));
  543. if (!os->sample_buffer)
  544. return -ENOMEM;
  545. list_add(&os->sample_buffer->list, &os->to_free);
  546. os->sample_buffer_idx = 2;
  547. new = os->sample_buffer + 1;
  548. }
  549. new->timestamp = timestamp;
  550. new->file_offset = file_offset;
  551. new->event = event;
  552. __queue_event(new, s);
  553. return 0;
  554. }
  555. static void callchain__printf(struct sample_data *sample)
  556. {
  557. unsigned int i;
  558. printf("... chain: nr:%Lu\n", sample->callchain->nr);
  559. for (i = 0; i < sample->callchain->nr; i++)
  560. printf("..... %2d: %016Lx\n", i, sample->callchain->ips[i]);
  561. }
  562. static void perf_session__print_tstamp(struct perf_session *session,
  563. event_t *event,
  564. struct sample_data *sample)
  565. {
  566. if (event->header.type != PERF_RECORD_SAMPLE &&
  567. !session->sample_id_all) {
  568. fputs("-1 -1 ", stdout);
  569. return;
  570. }
  571. if ((session->sample_type & PERF_SAMPLE_CPU))
  572. printf("%u ", sample->cpu);
  573. if (session->sample_type & PERF_SAMPLE_TIME)
  574. printf("%Lu ", sample->time);
  575. }
  576. static void dump_event(struct perf_session *session, event_t *event,
  577. u64 file_offset, struct sample_data *sample)
  578. {
  579. if (!dump_trace)
  580. return;
  581. printf("\n%#Lx [%#x]: event: %d\n", file_offset, event->header.size,
  582. event->header.type);
  583. trace_event(event);
  584. if (sample)
  585. perf_session__print_tstamp(session, event, sample);
  586. printf("%#Lx [%#x]: PERF_RECORD_%s", file_offset, event->header.size,
  587. event__get_event_name(event->header.type));
  588. }
  589. static void dump_sample(struct perf_session *session, event_t *event,
  590. struct sample_data *sample)
  591. {
  592. if (!dump_trace)
  593. return;
  594. printf("(IP, %d): %d/%d: %#Lx period: %Ld\n", event->header.misc,
  595. sample->pid, sample->tid, sample->ip, sample->period);
  596. if (session->sample_type & PERF_SAMPLE_CALLCHAIN)
  597. callchain__printf(sample);
  598. }
  599. static int perf_session_deliver_event(struct perf_session *session,
  600. event_t *event,
  601. struct sample_data *sample,
  602. struct perf_event_ops *ops,
  603. u64 file_offset)
  604. {
  605. dump_event(session, event, file_offset, sample);
  606. switch (event->header.type) {
  607. case PERF_RECORD_SAMPLE:
  608. dump_sample(session, event, sample);
  609. return ops->sample(event, sample, session);
  610. case PERF_RECORD_MMAP:
  611. return ops->mmap(event, sample, session);
  612. case PERF_RECORD_COMM:
  613. return ops->comm(event, sample, session);
  614. case PERF_RECORD_FORK:
  615. return ops->fork(event, sample, session);
  616. case PERF_RECORD_EXIT:
  617. return ops->exit(event, sample, session);
  618. case PERF_RECORD_LOST:
  619. return ops->lost(event, sample, session);
  620. case PERF_RECORD_READ:
  621. return ops->read(event, sample, session);
  622. case PERF_RECORD_THROTTLE:
  623. return ops->throttle(event, sample, session);
  624. case PERF_RECORD_UNTHROTTLE:
  625. return ops->unthrottle(event, sample, session);
  626. default:
  627. ++session->hists.stats.nr_unknown_events;
  628. return -1;
  629. }
  630. }
  631. static int perf_session__preprocess_sample(struct perf_session *session,
  632. event_t *event, struct sample_data *sample)
  633. {
  634. if (event->header.type != PERF_RECORD_SAMPLE ||
  635. !(session->sample_type & PERF_SAMPLE_CALLCHAIN))
  636. return 0;
  637. if (!ip_callchain__valid(sample->callchain, event)) {
  638. pr_debug("call-chain problem with event, skipping it.\n");
  639. ++session->hists.stats.nr_invalid_chains;
  640. session->hists.stats.total_invalid_chains += sample->period;
  641. return -EINVAL;
  642. }
  643. return 0;
  644. }
  645. static int perf_session__process_user_event(struct perf_session *session, event_t *event,
  646. struct perf_event_ops *ops, u64 file_offset)
  647. {
  648. dump_event(session, event, file_offset, NULL);
  649. /* These events are processed right away */
  650. switch (event->header.type) {
  651. case PERF_RECORD_HEADER_ATTR:
  652. return ops->attr(event, session);
  653. case PERF_RECORD_HEADER_EVENT_TYPE:
  654. return ops->event_type(event, session);
  655. case PERF_RECORD_HEADER_TRACING_DATA:
  656. /* setup for reading amidst mmap */
  657. lseek(session->fd, file_offset, SEEK_SET);
  658. return ops->tracing_data(event, session);
  659. case PERF_RECORD_HEADER_BUILD_ID:
  660. return ops->build_id(event, session);
  661. case PERF_RECORD_FINISHED_ROUND:
  662. return ops->finished_round(event, session, ops);
  663. default:
  664. return -EINVAL;
  665. }
  666. }
  667. static int perf_session__process_event(struct perf_session *session,
  668. event_t *event,
  669. struct perf_event_ops *ops,
  670. u64 file_offset)
  671. {
  672. struct sample_data sample;
  673. int ret;
  674. if (session->header.needs_swap && event__swap_ops[event->header.type])
  675. event__swap_ops[event->header.type](event);
  676. if (event->header.type >= PERF_RECORD_HEADER_MAX)
  677. return -EINVAL;
  678. hists__inc_nr_events(&session->hists, event->header.type);
  679. if (event->header.type >= PERF_RECORD_USER_TYPE_START)
  680. return perf_session__process_user_event(session, event, ops, file_offset);
  681. /*
  682. * For all kernel events we get the sample data
  683. */
  684. event__parse_sample(event, session, &sample);
  685. /* Preprocess sample records - precheck callchains */
  686. if (perf_session__preprocess_sample(session, event, &sample))
  687. return 0;
  688. if (ops->ordered_samples) {
  689. ret = perf_session_queue_event(session, event, &sample,
  690. file_offset);
  691. if (ret != -ETIME)
  692. return ret;
  693. }
  694. return perf_session_deliver_event(session, event, &sample, ops,
  695. file_offset);
  696. }
  697. void perf_event_header__bswap(struct perf_event_header *self)
  698. {
  699. self->type = bswap_32(self->type);
  700. self->misc = bswap_16(self->misc);
  701. self->size = bswap_16(self->size);
  702. }
  703. static struct thread *perf_session__register_idle_thread(struct perf_session *self)
  704. {
  705. struct thread *thread = perf_session__findnew(self, 0);
  706. if (thread == NULL || thread__set_comm(thread, "swapper")) {
  707. pr_err("problem inserting idle task.\n");
  708. thread = NULL;
  709. }
  710. return thread;
  711. }
  712. int do_read(int fd, void *buf, size_t size)
  713. {
  714. void *buf_start = buf;
  715. while (size) {
  716. int ret = read(fd, buf, size);
  717. if (ret <= 0)
  718. return ret;
  719. size -= ret;
  720. buf += ret;
  721. }
  722. return buf - buf_start;
  723. }
  724. #define session_done() (*(volatile int *)(&session_done))
  725. volatile int session_done;
  726. static int __perf_session__process_pipe_events(struct perf_session *self,
  727. struct perf_event_ops *ops)
  728. {
  729. event_t event;
  730. uint32_t size;
  731. int skip = 0;
  732. u64 head;
  733. int err;
  734. void *p;
  735. perf_event_ops__fill_defaults(ops);
  736. head = 0;
  737. more:
  738. err = do_read(self->fd, &event, sizeof(struct perf_event_header));
  739. if (err <= 0) {
  740. if (err == 0)
  741. goto done;
  742. pr_err("failed to read event header\n");
  743. goto out_err;
  744. }
  745. if (self->header.needs_swap)
  746. perf_event_header__bswap(&event.header);
  747. size = event.header.size;
  748. if (size == 0)
  749. size = 8;
  750. p = &event;
  751. p += sizeof(struct perf_event_header);
  752. if (size - sizeof(struct perf_event_header)) {
  753. err = do_read(self->fd, p,
  754. size - sizeof(struct perf_event_header));
  755. if (err <= 0) {
  756. if (err == 0) {
  757. pr_err("unexpected end of event stream\n");
  758. goto done;
  759. }
  760. pr_err("failed to read event data\n");
  761. goto out_err;
  762. }
  763. }
  764. if (size == 0 ||
  765. (skip = perf_session__process_event(self, &event, ops, head)) < 0) {
  766. dump_printf("%#Lx [%#x]: skipping unknown header type: %d\n",
  767. head, event.header.size, event.header.type);
  768. /*
  769. * assume we lost track of the stream, check alignment, and
  770. * increment a single u64 in the hope to catch on again 'soon'.
  771. */
  772. if (unlikely(head & 7))
  773. head &= ~7ULL;
  774. size = 8;
  775. }
  776. head += size;
  777. if (skip > 0)
  778. head += skip;
  779. if (!session_done())
  780. goto more;
  781. done:
  782. err = 0;
  783. out_err:
  784. perf_session_free_sample_buffers(self);
  785. return err;
  786. }
  787. int __perf_session__process_events(struct perf_session *session,
  788. u64 data_offset, u64 data_size,
  789. u64 file_size, struct perf_event_ops *ops)
  790. {
  791. u64 head, page_offset, file_offset, file_pos, progress_next;
  792. int err, mmap_prot, mmap_flags, map_idx = 0;
  793. struct ui_progress *progress;
  794. size_t page_size, mmap_size;
  795. char *buf, *mmaps[8];
  796. event_t *event;
  797. uint32_t size;
  798. perf_event_ops__fill_defaults(ops);
  799. page_size = sysconf(_SC_PAGESIZE);
  800. page_offset = page_size * (data_offset / page_size);
  801. file_offset = page_offset;
  802. head = data_offset - page_offset;
  803. if (data_offset + data_size < file_size)
  804. file_size = data_offset + data_size;
  805. progress_next = file_size / 16;
  806. progress = ui_progress__new("Processing events...", file_size);
  807. if (progress == NULL)
  808. return -1;
  809. mmap_size = session->mmap_window;
  810. if (mmap_size > file_size)
  811. mmap_size = file_size;
  812. memset(mmaps, 0, sizeof(mmaps));
  813. mmap_prot = PROT_READ;
  814. mmap_flags = MAP_SHARED;
  815. if (session->header.needs_swap) {
  816. mmap_prot |= PROT_WRITE;
  817. mmap_flags = MAP_PRIVATE;
  818. }
  819. remap:
  820. buf = mmap(NULL, mmap_size, mmap_prot, mmap_flags, session->fd,
  821. file_offset);
  822. if (buf == MAP_FAILED) {
  823. pr_err("failed to mmap file\n");
  824. err = -errno;
  825. goto out_err;
  826. }
  827. mmaps[map_idx] = buf;
  828. map_idx = (map_idx + 1) & (ARRAY_SIZE(mmaps) - 1);
  829. file_pos = file_offset + head;
  830. more:
  831. event = (event_t *)(buf + head);
  832. if (session->header.needs_swap)
  833. perf_event_header__bswap(&event->header);
  834. size = event->header.size;
  835. if (size == 0)
  836. size = 8;
  837. if (head + event->header.size >= mmap_size) {
  838. if (mmaps[map_idx]) {
  839. munmap(mmaps[map_idx], mmap_size);
  840. mmaps[map_idx] = NULL;
  841. }
  842. page_offset = page_size * (head / page_size);
  843. file_offset += page_offset;
  844. head -= page_offset;
  845. goto remap;
  846. }
  847. size = event->header.size;
  848. if (size == 0 ||
  849. perf_session__process_event(session, event, ops, file_pos) < 0) {
  850. dump_printf("%#Lx [%#x]: skipping unknown header type: %d\n",
  851. file_offset + head, event->header.size,
  852. event->header.type);
  853. /*
  854. * assume we lost track of the stream, check alignment, and
  855. * increment a single u64 in the hope to catch on again 'soon'.
  856. */
  857. if (unlikely(head & 7))
  858. head &= ~7ULL;
  859. size = 8;
  860. }
  861. head += size;
  862. file_pos += size;
  863. if (file_pos >= progress_next) {
  864. progress_next += file_size / 16;
  865. ui_progress__update(progress, file_pos);
  866. }
  867. if (file_pos < file_size)
  868. goto more;
  869. err = 0;
  870. /* do the final flush for ordered samples */
  871. session->ordered_samples.next_flush = ULLONG_MAX;
  872. flush_sample_queue(session, ops);
  873. out_err:
  874. ui_progress__delete(progress);
  875. if (ops->lost == event__process_lost &&
  876. session->hists.stats.total_lost != 0) {
  877. ui__warning("Processed %Lu events and LOST %Lu!\n\n"
  878. "Check IO/CPU overload!\n\n",
  879. session->hists.stats.total_period,
  880. session->hists.stats.total_lost);
  881. }
  882. if (session->hists.stats.nr_unknown_events != 0) {
  883. ui__warning("Found %u unknown events!\n\n"
  884. "Is this an older tool processing a perf.data "
  885. "file generated by a more recent tool?\n\n"
  886. "If that is not the case, consider "
  887. "reporting to linux-kernel@vger.kernel.org.\n\n",
  888. session->hists.stats.nr_unknown_events);
  889. }
  890. if (session->hists.stats.nr_invalid_chains != 0) {
  891. ui__warning("Found invalid callchains!\n\n"
  892. "%u out of %u events were discarded for this reason.\n\n"
  893. "Consider reporting to linux-kernel@vger.kernel.org.\n\n",
  894. session->hists.stats.nr_invalid_chains,
  895. session->hists.stats.nr_events[PERF_RECORD_SAMPLE]);
  896. }
  897. perf_session_free_sample_buffers(session);
  898. return err;
  899. }
  900. int perf_session__process_events(struct perf_session *self,
  901. struct perf_event_ops *ops)
  902. {
  903. int err;
  904. if (perf_session__register_idle_thread(self) == NULL)
  905. return -ENOMEM;
  906. if (!self->fd_pipe)
  907. err = __perf_session__process_events(self,
  908. self->header.data_offset,
  909. self->header.data_size,
  910. self->size, ops);
  911. else
  912. err = __perf_session__process_pipe_events(self, ops);
  913. return err;
  914. }
  915. bool perf_session__has_traces(struct perf_session *self, const char *msg)
  916. {
  917. if (!(self->sample_type & PERF_SAMPLE_RAW)) {
  918. pr_err("No trace sample to read. Did you call 'perf %s'?\n", msg);
  919. return false;
  920. }
  921. return true;
  922. }
  923. int perf_session__set_kallsyms_ref_reloc_sym(struct map **maps,
  924. const char *symbol_name,
  925. u64 addr)
  926. {
  927. char *bracket;
  928. enum map_type i;
  929. struct ref_reloc_sym *ref;
  930. ref = zalloc(sizeof(struct ref_reloc_sym));
  931. if (ref == NULL)
  932. return -ENOMEM;
  933. ref->name = strdup(symbol_name);
  934. if (ref->name == NULL) {
  935. free(ref);
  936. return -ENOMEM;
  937. }
  938. bracket = strchr(ref->name, ']');
  939. if (bracket)
  940. *bracket = '\0';
  941. ref->addr = addr;
  942. for (i = 0; i < MAP__NR_TYPES; ++i) {
  943. struct kmap *kmap = map__kmap(maps[i]);
  944. kmap->ref_reloc_sym = ref;
  945. }
  946. return 0;
  947. }
  948. size_t perf_session__fprintf_dsos(struct perf_session *self, FILE *fp)
  949. {
  950. return __dsos__fprintf(&self->host_machine.kernel_dsos, fp) +
  951. __dsos__fprintf(&self->host_machine.user_dsos, fp) +
  952. machines__fprintf_dsos(&self->machines, fp);
  953. }
  954. size_t perf_session__fprintf_dsos_buildid(struct perf_session *self, FILE *fp,
  955. bool with_hits)
  956. {
  957. size_t ret = machine__fprintf_dsos_buildid(&self->host_machine, fp, with_hits);
  958. return ret + machines__fprintf_dsos_buildid(&self->machines, fp, with_hits);
  959. }