session.c 68 KB

12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394959697989910010110210310410510610710810911011111211311411511611711811912012112212312412512612712812913013113213313413513613713813914014114214314414514614714814915015115215315415515615715815916016116216316416516616716816917017117217317417517617717817918018118218318418518618718818919019119219319419519619719819920020120220320420520620720820921021121221321421521621721821922022122222322422522622722822923023123223323423523623723823924024124224324424524624724824925025125225325425525625725825926026126226326426526626726826927027127227327427527627727827928028128228328428528628728828929029129229329429529629729829930030130230330430530630730830931031131231331431531631731831932032132232332432532632732832933033133233333433533633733833934034134234334434534634734834935035135235335435535635735835936036136236336436536636736836937037137237337437537637737837938038138238338438538638738838939039139239339439539639739839940040140240340440540640740840941041141241341441541641741841942042142242342442542642742842943043143243343443543643743843944044144244344444544644744844945045145245345445545645745845946046146246346446546646746846947047147247347447547647747847948048148248348448548648748848949049149249349449549649749849950050150250350450550650750850951051151251351451551651751851952052152252352452552652752852953053153253353453553653753853954054154254354454554654754854955055155255355455555655755855956056156256356456556656756856957057157257357457557657757857958058158258358458558658758858959059159259359459559659759859960060160260360460560660760860961061161261361461561661761861962062162262362462562662762862963063163263363463563663763863964064164264364464564664764864965065165265365465565665765865966066166266366466566666766866967067167267367467567667767867968068168268368468568668768868969069169269369469569669769869970070170270370470570670770870971071171271371471571671771871972072172272372472572672772872973073173273373473573673773873974074174274374474574674774874975075175275375475575675775875976076176276376476576676776876977077177277377477577677777877978078178278378478578678778878979079179279379479579679779879980080180280380480580680780880981081181281381481581681781881982082182282382482582682782882983083183283383483583683783883984084184284384484584684784884985085185285385485585685785885986086186286386486586686786886987087187287387487587687787887988088188288388488588688788888989089189289389489589689789889990090190290390490590690790890991091191291391491591691791891992092192292392492592692792892993093193293393493593693793893994094194294394494594694794894995095195295395495595695795895996096196296396496596696796896997097197297397497597697797897998098198298398498598698798898999099199299399499599699799899910001001100210031004100510061007100810091010101110121013101410151016101710181019102010211022102310241025102610271028102910301031103210331034103510361037103810391040104110421043104410451046104710481049105010511052105310541055105610571058105910601061106210631064106510661067106810691070107110721073107410751076107710781079108010811082108310841085108610871088108910901091109210931094109510961097109810991100110111021103110411051106110711081109111011111112111311141115111611171118111911201121112211231124112511261127112811291130113111321133113411351136113711381139114011411142114311441145114611471148114911501151115211531154115511561157115811591160116111621163116411651166116711681169117011711172117311741175117611771178117911801181118211831184118511861187118811891190119111921193119411951196119711981199120012011202120312041205120612071208120912101211121212131214121512161217121812191220122112221223122412251226122712281229123012311232123312341235123612371238123912401241124212431244124512461247124812491250125112521253125412551256125712581259126012611262126312641265126612671268126912701271127212731274127512761277127812791280128112821283128412851286128712881289129012911292129312941295129612971298129913001301130213031304130513061307130813091310131113121313131413151316131713181319132013211322132313241325132613271328132913301331133213331334133513361337133813391340134113421343134413451346134713481349135013511352135313541355135613571358135913601361136213631364136513661367136813691370137113721373137413751376137713781379138013811382138313841385138613871388138913901391139213931394139513961397139813991400140114021403140414051406140714081409141014111412141314141415141614171418141914201421142214231424142514261427142814291430143114321433143414351436143714381439144014411442144314441445144614471448144914501451145214531454145514561457145814591460146114621463146414651466146714681469147014711472147314741475147614771478147914801481148214831484148514861487148814891490149114921493149414951496149714981499150015011502150315041505150615071508150915101511151215131514151515161517151815191520152115221523152415251526152715281529153015311532153315341535153615371538153915401541154215431544154515461547154815491550155115521553155415551556155715581559156015611562156315641565156615671568156915701571157215731574157515761577157815791580158115821583158415851586158715881589159015911592159315941595159615971598159916001601160216031604160516061607160816091610161116121613161416151616161716181619162016211622162316241625162616271628162916301631163216331634163516361637163816391640164116421643164416451646164716481649165016511652165316541655165616571658165916601661166216631664166516661667166816691670167116721673167416751676167716781679168016811682168316841685168616871688168916901691169216931694169516961697169816991700170117021703170417051706170717081709171017111712171317141715171617171718171917201721172217231724172517261727172817291730173117321733173417351736173717381739174017411742174317441745174617471748174917501751175217531754175517561757175817591760176117621763176417651766176717681769177017711772177317741775177617771778177917801781178217831784178517861787178817891790179117921793179417951796179717981799180018011802180318041805180618071808180918101811181218131814181518161817181818191820182118221823182418251826182718281829183018311832183318341835183618371838183918401841184218431844184518461847184818491850185118521853185418551856185718581859186018611862186318641865186618671868186918701871187218731874187518761877187818791880188118821883188418851886188718881889189018911892189318941895189618971898189919001901190219031904190519061907190819091910191119121913191419151916191719181919192019211922192319241925192619271928192919301931193219331934193519361937193819391940194119421943194419451946194719481949195019511952195319541955195619571958195919601961196219631964196519661967196819691970197119721973197419751976197719781979198019811982198319841985198619871988198919901991199219931994199519961997199819992000200120022003200420052006200720082009201020112012201320142015201620172018201920202021202220232024202520262027202820292030203120322033203420352036203720382039204020412042204320442045204620472048204920502051205220532054205520562057205820592060206120622063206420652066206720682069207020712072207320742075207620772078207920802081208220832084208520862087208820892090209120922093209420952096209720982099210021012102210321042105210621072108210921102111211221132114211521162117211821192120212121222123212421252126212721282129213021312132213321342135213621372138213921402141214221432144214521462147214821492150215121522153215421552156215721582159216021612162216321642165216621672168216921702171217221732174217521762177217821792180218121822183218421852186218721882189219021912192219321942195219621972198219922002201220222032204220522062207220822092210221122122213221422152216221722182219222022212222222322242225222622272228222922302231223222332234223522362237223822392240224122422243224422452246224722482249225022512252225322542255225622572258225922602261226222632264226522662267226822692270227122722273227422752276227722782279228022812282228322842285228622872288228922902291229222932294229522962297229822992300230123022303230423052306230723082309231023112312231323142315231623172318231923202321232223232324232523262327232823292330233123322333233423352336233723382339234023412342234323442345234623472348234923502351235223532354235523562357235823592360236123622363236423652366236723682369237023712372237323742375237623772378237923802381238223832384238523862387238823892390239123922393239423952396239723982399240024012402240324042405240624072408240924102411241224132414241524162417241824192420242124222423242424252426242724282429243024312432243324342435243624372438243924402441244224432444244524462447244824492450245124522453245424552456245724582459246024612462246324642465246624672468246924702471247224732474247524762477247824792480248124822483248424852486248724882489249024912492249324942495249624972498249925002501250225032504250525062507250825092510
  1. // SPDX-License-Identifier: GPL-2.0
  2. #include <errno.h>
  3. #include <inttypes.h>
  4. #include <linux/err.h>
  5. #include <linux/kernel.h>
  6. #include <linux/zalloc.h>
  7. #include <api/fs/fs.h>
  8. #include <byteswap.h>
  9. #include <unistd.h>
  10. #include <sys/types.h>
  11. #include <sys/mman.h>
  12. #include <perf/cpumap.h>
  13. #include "map_symbol.h"
  14. #include "branch.h"
  15. #include "debug.h"
  16. #include "evlist.h"
  17. #include "evsel.h"
  18. #include "memswap.h"
  19. #include "map.h"
  20. #include "symbol.h"
  21. #include "session.h"
  22. #include "tool.h"
  23. #include "perf_regs.h"
  24. #include "asm/bug.h"
  25. #include "auxtrace.h"
  26. #include "thread.h"
  27. #include "thread-stack.h"
  28. #include "sample-raw.h"
  29. #include "stat.h"
  30. #include "ui/progress.h"
  31. #include "../perf.h"
  32. #include "arch/common.h"
  33. #include <internal/lib.h>
  34. #ifdef HAVE_ZSTD_SUPPORT
  35. static int perf_session__process_compressed_event(struct perf_session *session,
  36. union perf_event *event, u64 file_offset)
  37. {
  38. void *src;
  39. size_t decomp_size, src_size;
  40. u64 decomp_last_rem = 0;
  41. size_t mmap_len, decomp_len = session->header.env.comp_mmap_len;
  42. struct decomp *decomp, *decomp_last = session->decomp_last;
  43. if (decomp_last) {
  44. decomp_last_rem = decomp_last->size - decomp_last->head;
  45. decomp_len += decomp_last_rem;
  46. }
  47. mmap_len = sizeof(struct decomp) + decomp_len;
  48. decomp = mmap(NULL, mmap_len, PROT_READ|PROT_WRITE,
  49. MAP_ANONYMOUS|MAP_PRIVATE, -1, 0);
  50. if (decomp == MAP_FAILED) {
  51. pr_err("Couldn't allocate memory for decompression\n");
  52. return -1;
  53. }
  54. decomp->file_pos = file_offset;
  55. decomp->mmap_len = mmap_len;
  56. decomp->head = 0;
  57. if (decomp_last_rem) {
  58. memcpy(decomp->data, &(decomp_last->data[decomp_last->head]), decomp_last_rem);
  59. decomp->size = decomp_last_rem;
  60. }
  61. src = (void *)event + sizeof(struct perf_record_compressed);
  62. src_size = event->pack.header.size - sizeof(struct perf_record_compressed);
  63. decomp_size = zstd_decompress_stream(&(session->zstd_data), src, src_size,
  64. &(decomp->data[decomp_last_rem]), decomp_len - decomp_last_rem);
  65. if (!decomp_size) {
  66. munmap(decomp, mmap_len);
  67. pr_err("Couldn't decompress data\n");
  68. return -1;
  69. }
  70. decomp->size += decomp_size;
  71. if (session->decomp == NULL) {
  72. session->decomp = decomp;
  73. session->decomp_last = decomp;
  74. } else {
  75. session->decomp_last->next = decomp;
  76. session->decomp_last = decomp;
  77. }
  78. pr_debug("decomp (B): %zd to %zd\n", src_size, decomp_size);
  79. return 0;
  80. }
  81. #else /* !HAVE_ZSTD_SUPPORT */
  82. #define perf_session__process_compressed_event perf_session__process_compressed_event_stub
  83. #endif
  84. static int perf_session__deliver_event(struct perf_session *session,
  85. union perf_event *event,
  86. struct perf_tool *tool,
  87. u64 file_offset);
  88. static int perf_session__open(struct perf_session *session)
  89. {
  90. struct perf_data *data = session->data;
  91. if (perf_session__read_header(session) < 0) {
  92. pr_err("incompatible file format (rerun with -v to learn more)\n");
  93. return -1;
  94. }
  95. if (perf_data__is_pipe(data))
  96. return 0;
  97. if (perf_header__has_feat(&session->header, HEADER_STAT))
  98. return 0;
  99. if (!evlist__valid_sample_type(session->evlist)) {
  100. pr_err("non matching sample_type\n");
  101. return -1;
  102. }
  103. if (!evlist__valid_sample_id_all(session->evlist)) {
  104. pr_err("non matching sample_id_all\n");
  105. return -1;
  106. }
  107. if (!perf_evlist__valid_read_format(session->evlist)) {
  108. pr_err("non matching read_format\n");
  109. return -1;
  110. }
  111. return 0;
  112. }
  113. void perf_session__set_id_hdr_size(struct perf_session *session)
  114. {
  115. u16 id_hdr_size = perf_evlist__id_hdr_size(session->evlist);
  116. machines__set_id_hdr_size(&session->machines, id_hdr_size);
  117. }
  118. int perf_session__create_kernel_maps(struct perf_session *session)
  119. {
  120. int ret = machine__create_kernel_maps(&session->machines.host);
  121. if (ret >= 0)
  122. ret = machines__create_guest_kernel_maps(&session->machines);
  123. return ret;
  124. }
  125. static void perf_session__destroy_kernel_maps(struct perf_session *session)
  126. {
  127. machines__destroy_kernel_maps(&session->machines);
  128. }
  129. static bool perf_session__has_comm_exec(struct perf_session *session)
  130. {
  131. struct evsel *evsel;
  132. evlist__for_each_entry(session->evlist, evsel) {
  133. if (evsel->core.attr.comm_exec)
  134. return true;
  135. }
  136. return false;
  137. }
  138. static void perf_session__set_comm_exec(struct perf_session *session)
  139. {
  140. bool comm_exec = perf_session__has_comm_exec(session);
  141. machines__set_comm_exec(&session->machines, comm_exec);
  142. }
  143. static int ordered_events__deliver_event(struct ordered_events *oe,
  144. struct ordered_event *event)
  145. {
  146. struct perf_session *session = container_of(oe, struct perf_session,
  147. ordered_events);
  148. return perf_session__deliver_event(session, event->event,
  149. session->tool, event->file_offset);
  150. }
  151. struct perf_session *perf_session__new(struct perf_data *data,
  152. bool repipe, struct perf_tool *tool)
  153. {
  154. int ret = -ENOMEM;
  155. struct perf_session *session = zalloc(sizeof(*session));
  156. if (!session)
  157. goto out;
  158. session->repipe = repipe;
  159. session->tool = tool;
  160. INIT_LIST_HEAD(&session->auxtrace_index);
  161. machines__init(&session->machines);
  162. ordered_events__init(&session->ordered_events,
  163. ordered_events__deliver_event, NULL);
  164. perf_env__init(&session->header.env);
  165. if (data) {
  166. ret = perf_data__open(data);
  167. if (ret < 0)
  168. goto out_delete;
  169. session->data = data;
  170. if (perf_data__is_read(data)) {
  171. ret = perf_session__open(session);
  172. if (ret < 0)
  173. goto out_delete;
  174. /*
  175. * set session attributes that are present in perf.data
  176. * but not in pipe-mode.
  177. */
  178. if (!data->is_pipe) {
  179. perf_session__set_id_hdr_size(session);
  180. perf_session__set_comm_exec(session);
  181. }
  182. perf_evlist__init_trace_event_sample_raw(session->evlist);
  183. /* Open the directory data. */
  184. if (data->is_dir) {
  185. ret = perf_data__open_dir(data);
  186. if (ret)
  187. goto out_delete;
  188. }
  189. if (!symbol_conf.kallsyms_name &&
  190. !symbol_conf.vmlinux_name)
  191. symbol_conf.kallsyms_name = perf_data__kallsyms_name(data);
  192. }
  193. } else {
  194. session->machines.host.env = &perf_env;
  195. }
  196. session->machines.host.single_address_space =
  197. perf_env__single_address_space(session->machines.host.env);
  198. if (!data || perf_data__is_write(data)) {
  199. /*
  200. * In O_RDONLY mode this will be performed when reading the
  201. * kernel MMAP event, in perf_event__process_mmap().
  202. */
  203. if (perf_session__create_kernel_maps(session) < 0)
  204. pr_warning("Cannot read kernel map\n");
  205. }
  206. /*
  207. * In pipe-mode, evlist is empty until PERF_RECORD_HEADER_ATTR is
  208. * processed, so evlist__sample_id_all is not meaningful here.
  209. */
  210. if ((!data || !data->is_pipe) && tool && tool->ordering_requires_timestamps &&
  211. tool->ordered_events && !evlist__sample_id_all(session->evlist)) {
  212. dump_printf("WARNING: No sample_id_all support, falling back to unordered processing\n");
  213. tool->ordered_events = false;
  214. }
  215. return session;
  216. out_delete:
  217. perf_session__delete(session);
  218. out:
  219. return ERR_PTR(ret);
  220. }
  221. static void perf_session__delete_threads(struct perf_session *session)
  222. {
  223. machine__delete_threads(&session->machines.host);
  224. }
  225. static void perf_session__release_decomp_events(struct perf_session *session)
  226. {
  227. struct decomp *next, *decomp;
  228. size_t mmap_len;
  229. next = session->decomp;
  230. do {
  231. decomp = next;
  232. if (decomp == NULL)
  233. break;
  234. next = decomp->next;
  235. mmap_len = decomp->mmap_len;
  236. munmap(decomp, mmap_len);
  237. } while (1);
  238. }
  239. void perf_session__delete(struct perf_session *session)
  240. {
  241. if (session == NULL)
  242. return;
  243. auxtrace__free(session);
  244. auxtrace_index__free(&session->auxtrace_index);
  245. perf_session__destroy_kernel_maps(session);
  246. perf_session__delete_threads(session);
  247. perf_session__release_decomp_events(session);
  248. perf_env__exit(&session->header.env);
  249. machines__exit(&session->machines);
  250. if (session->data)
  251. perf_data__close(session->data);
  252. free(session);
  253. }
  254. static int process_event_synth_tracing_data_stub(struct perf_session *session
  255. __maybe_unused,
  256. union perf_event *event
  257. __maybe_unused)
  258. {
  259. dump_printf(": unhandled!\n");
  260. return 0;
  261. }
  262. static int process_event_synth_attr_stub(struct perf_tool *tool __maybe_unused,
  263. union perf_event *event __maybe_unused,
  264. struct evlist **pevlist
  265. __maybe_unused)
  266. {
  267. dump_printf(": unhandled!\n");
  268. return 0;
  269. }
  270. static int process_event_synth_event_update_stub(struct perf_tool *tool __maybe_unused,
  271. union perf_event *event __maybe_unused,
  272. struct evlist **pevlist
  273. __maybe_unused)
  274. {
  275. if (dump_trace)
  276. perf_event__fprintf_event_update(event, stdout);
  277. dump_printf(": unhandled!\n");
  278. return 0;
  279. }
  280. static int process_event_sample_stub(struct perf_tool *tool __maybe_unused,
  281. union perf_event *event __maybe_unused,
  282. struct perf_sample *sample __maybe_unused,
  283. struct evsel *evsel __maybe_unused,
  284. struct machine *machine __maybe_unused)
  285. {
  286. dump_printf(": unhandled!\n");
  287. return 0;
  288. }
  289. static int process_event_stub(struct perf_tool *tool __maybe_unused,
  290. union perf_event *event __maybe_unused,
  291. struct perf_sample *sample __maybe_unused,
  292. struct machine *machine __maybe_unused)
  293. {
  294. dump_printf(": unhandled!\n");
  295. return 0;
  296. }
  297. static int process_finished_round_stub(struct perf_tool *tool __maybe_unused,
  298. union perf_event *event __maybe_unused,
  299. struct ordered_events *oe __maybe_unused)
  300. {
  301. dump_printf(": unhandled!\n");
  302. return 0;
  303. }
  304. static int process_finished_round(struct perf_tool *tool,
  305. union perf_event *event,
  306. struct ordered_events *oe);
  307. static int skipn(int fd, off_t n)
  308. {
  309. char buf[4096];
  310. ssize_t ret;
  311. while (n > 0) {
  312. ret = read(fd, buf, min(n, (off_t)sizeof(buf)));
  313. if (ret <= 0)
  314. return ret;
  315. n -= ret;
  316. }
  317. return 0;
  318. }
  319. static s64 process_event_auxtrace_stub(struct perf_session *session __maybe_unused,
  320. union perf_event *event)
  321. {
  322. dump_printf(": unhandled!\n");
  323. if (perf_data__is_pipe(session->data))
  324. skipn(perf_data__fd(session->data), event->auxtrace.size);
  325. return event->auxtrace.size;
  326. }
  327. static int process_event_op2_stub(struct perf_session *session __maybe_unused,
  328. union perf_event *event __maybe_unused)
  329. {
  330. dump_printf(": unhandled!\n");
  331. return 0;
  332. }
  333. static
  334. int process_event_thread_map_stub(struct perf_session *session __maybe_unused,
  335. union perf_event *event __maybe_unused)
  336. {
  337. if (dump_trace)
  338. perf_event__fprintf_thread_map(event, stdout);
  339. dump_printf(": unhandled!\n");
  340. return 0;
  341. }
  342. static
  343. int process_event_cpu_map_stub(struct perf_session *session __maybe_unused,
  344. union perf_event *event __maybe_unused)
  345. {
  346. if (dump_trace)
  347. perf_event__fprintf_cpu_map(event, stdout);
  348. dump_printf(": unhandled!\n");
  349. return 0;
  350. }
  351. static
  352. int process_event_stat_config_stub(struct perf_session *session __maybe_unused,
  353. union perf_event *event __maybe_unused)
  354. {
  355. if (dump_trace)
  356. perf_event__fprintf_stat_config(event, stdout);
  357. dump_printf(": unhandled!\n");
  358. return 0;
  359. }
  360. static int process_stat_stub(struct perf_session *perf_session __maybe_unused,
  361. union perf_event *event)
  362. {
  363. if (dump_trace)
  364. perf_event__fprintf_stat(event, stdout);
  365. dump_printf(": unhandled!\n");
  366. return 0;
  367. }
  368. static int process_stat_round_stub(struct perf_session *perf_session __maybe_unused,
  369. union perf_event *event)
  370. {
  371. if (dump_trace)
  372. perf_event__fprintf_stat_round(event, stdout);
  373. dump_printf(": unhandled!\n");
  374. return 0;
  375. }
  376. static int perf_session__process_compressed_event_stub(struct perf_session *session __maybe_unused,
  377. union perf_event *event __maybe_unused,
  378. u64 file_offset __maybe_unused)
  379. {
  380. dump_printf(": unhandled!\n");
  381. return 0;
  382. }
  383. void perf_tool__fill_defaults(struct perf_tool *tool)
  384. {
  385. if (tool->sample == NULL)
  386. tool->sample = process_event_sample_stub;
  387. if (tool->mmap == NULL)
  388. tool->mmap = process_event_stub;
  389. if (tool->mmap2 == NULL)
  390. tool->mmap2 = process_event_stub;
  391. if (tool->comm == NULL)
  392. tool->comm = process_event_stub;
  393. if (tool->namespaces == NULL)
  394. tool->namespaces = process_event_stub;
  395. if (tool->cgroup == NULL)
  396. tool->cgroup = process_event_stub;
  397. if (tool->fork == NULL)
  398. tool->fork = process_event_stub;
  399. if (tool->exit == NULL)
  400. tool->exit = process_event_stub;
  401. if (tool->lost == NULL)
  402. tool->lost = perf_event__process_lost;
  403. if (tool->lost_samples == NULL)
  404. tool->lost_samples = perf_event__process_lost_samples;
  405. if (tool->aux == NULL)
  406. tool->aux = perf_event__process_aux;
  407. if (tool->itrace_start == NULL)
  408. tool->itrace_start = perf_event__process_itrace_start;
  409. if (tool->context_switch == NULL)
  410. tool->context_switch = perf_event__process_switch;
  411. if (tool->ksymbol == NULL)
  412. tool->ksymbol = perf_event__process_ksymbol;
  413. if (tool->bpf == NULL)
  414. tool->bpf = perf_event__process_bpf;
  415. if (tool->text_poke == NULL)
  416. tool->text_poke = perf_event__process_text_poke;
  417. if (tool->read == NULL)
  418. tool->read = process_event_sample_stub;
  419. if (tool->throttle == NULL)
  420. tool->throttle = process_event_stub;
  421. if (tool->unthrottle == NULL)
  422. tool->unthrottle = process_event_stub;
  423. if (tool->attr == NULL)
  424. tool->attr = process_event_synth_attr_stub;
  425. if (tool->event_update == NULL)
  426. tool->event_update = process_event_synth_event_update_stub;
  427. if (tool->tracing_data == NULL)
  428. tool->tracing_data = process_event_synth_tracing_data_stub;
  429. if (tool->build_id == NULL)
  430. tool->build_id = process_event_op2_stub;
  431. if (tool->finished_round == NULL) {
  432. if (tool->ordered_events)
  433. tool->finished_round = process_finished_round;
  434. else
  435. tool->finished_round = process_finished_round_stub;
  436. }
  437. if (tool->id_index == NULL)
  438. tool->id_index = process_event_op2_stub;
  439. if (tool->auxtrace_info == NULL)
  440. tool->auxtrace_info = process_event_op2_stub;
  441. if (tool->auxtrace == NULL)
  442. tool->auxtrace = process_event_auxtrace_stub;
  443. if (tool->auxtrace_error == NULL)
  444. tool->auxtrace_error = process_event_op2_stub;
  445. if (tool->thread_map == NULL)
  446. tool->thread_map = process_event_thread_map_stub;
  447. if (tool->cpu_map == NULL)
  448. tool->cpu_map = process_event_cpu_map_stub;
  449. if (tool->stat_config == NULL)
  450. tool->stat_config = process_event_stat_config_stub;
  451. if (tool->stat == NULL)
  452. tool->stat = process_stat_stub;
  453. if (tool->stat_round == NULL)
  454. tool->stat_round = process_stat_round_stub;
  455. if (tool->time_conv == NULL)
  456. tool->time_conv = process_event_op2_stub;
  457. if (tool->feature == NULL)
  458. tool->feature = process_event_op2_stub;
  459. if (tool->compressed == NULL)
  460. tool->compressed = perf_session__process_compressed_event;
  461. }
  462. static void swap_sample_id_all(union perf_event *event, void *data)
  463. {
  464. void *end = (void *) event + event->header.size;
  465. int size = end - data;
  466. BUG_ON(size % sizeof(u64));
  467. mem_bswap_64(data, size);
  468. }
  469. static void perf_event__all64_swap(union perf_event *event,
  470. bool sample_id_all __maybe_unused)
  471. {
  472. struct perf_event_header *hdr = &event->header;
  473. mem_bswap_64(hdr + 1, event->header.size - sizeof(*hdr));
  474. }
  475. static void perf_event__comm_swap(union perf_event *event, bool sample_id_all)
  476. {
  477. event->comm.pid = bswap_32(event->comm.pid);
  478. event->comm.tid = bswap_32(event->comm.tid);
  479. if (sample_id_all) {
  480. void *data = &event->comm.comm;
  481. data += PERF_ALIGN(strlen(data) + 1, sizeof(u64));
  482. swap_sample_id_all(event, data);
  483. }
  484. }
  485. static void perf_event__mmap_swap(union perf_event *event,
  486. bool sample_id_all)
  487. {
  488. event->mmap.pid = bswap_32(event->mmap.pid);
  489. event->mmap.tid = bswap_32(event->mmap.tid);
  490. event->mmap.start = bswap_64(event->mmap.start);
  491. event->mmap.len = bswap_64(event->mmap.len);
  492. event->mmap.pgoff = bswap_64(event->mmap.pgoff);
  493. if (sample_id_all) {
  494. void *data = &event->mmap.filename;
  495. data += PERF_ALIGN(strlen(data) + 1, sizeof(u64));
  496. swap_sample_id_all(event, data);
  497. }
  498. }
  499. static void perf_event__mmap2_swap(union perf_event *event,
  500. bool sample_id_all)
  501. {
  502. event->mmap2.pid = bswap_32(event->mmap2.pid);
  503. event->mmap2.tid = bswap_32(event->mmap2.tid);
  504. event->mmap2.start = bswap_64(event->mmap2.start);
  505. event->mmap2.len = bswap_64(event->mmap2.len);
  506. event->mmap2.pgoff = bswap_64(event->mmap2.pgoff);
  507. event->mmap2.maj = bswap_32(event->mmap2.maj);
  508. event->mmap2.min = bswap_32(event->mmap2.min);
  509. event->mmap2.ino = bswap_64(event->mmap2.ino);
  510. event->mmap2.ino_generation = bswap_64(event->mmap2.ino_generation);
  511. if (sample_id_all) {
  512. void *data = &event->mmap2.filename;
  513. data += PERF_ALIGN(strlen(data) + 1, sizeof(u64));
  514. swap_sample_id_all(event, data);
  515. }
  516. }
  517. static void perf_event__task_swap(union perf_event *event, bool sample_id_all)
  518. {
  519. event->fork.pid = bswap_32(event->fork.pid);
  520. event->fork.tid = bswap_32(event->fork.tid);
  521. event->fork.ppid = bswap_32(event->fork.ppid);
  522. event->fork.ptid = bswap_32(event->fork.ptid);
  523. event->fork.time = bswap_64(event->fork.time);
  524. if (sample_id_all)
  525. swap_sample_id_all(event, &event->fork + 1);
  526. }
  527. static void perf_event__read_swap(union perf_event *event, bool sample_id_all)
  528. {
  529. event->read.pid = bswap_32(event->read.pid);
  530. event->read.tid = bswap_32(event->read.tid);
  531. event->read.value = bswap_64(event->read.value);
  532. event->read.time_enabled = bswap_64(event->read.time_enabled);
  533. event->read.time_running = bswap_64(event->read.time_running);
  534. event->read.id = bswap_64(event->read.id);
  535. if (sample_id_all)
  536. swap_sample_id_all(event, &event->read + 1);
  537. }
  538. static void perf_event__aux_swap(union perf_event *event, bool sample_id_all)
  539. {
  540. event->aux.aux_offset = bswap_64(event->aux.aux_offset);
  541. event->aux.aux_size = bswap_64(event->aux.aux_size);
  542. event->aux.flags = bswap_64(event->aux.flags);
  543. if (sample_id_all)
  544. swap_sample_id_all(event, &event->aux + 1);
  545. }
  546. static void perf_event__itrace_start_swap(union perf_event *event,
  547. bool sample_id_all)
  548. {
  549. event->itrace_start.pid = bswap_32(event->itrace_start.pid);
  550. event->itrace_start.tid = bswap_32(event->itrace_start.tid);
  551. if (sample_id_all)
  552. swap_sample_id_all(event, &event->itrace_start + 1);
  553. }
  554. static void perf_event__switch_swap(union perf_event *event, bool sample_id_all)
  555. {
  556. if (event->header.type == PERF_RECORD_SWITCH_CPU_WIDE) {
  557. event->context_switch.next_prev_pid =
  558. bswap_32(event->context_switch.next_prev_pid);
  559. event->context_switch.next_prev_tid =
  560. bswap_32(event->context_switch.next_prev_tid);
  561. }
  562. if (sample_id_all)
  563. swap_sample_id_all(event, &event->context_switch + 1);
  564. }
  565. static void perf_event__text_poke_swap(union perf_event *event, bool sample_id_all)
  566. {
  567. event->text_poke.addr = bswap_64(event->text_poke.addr);
  568. event->text_poke.old_len = bswap_16(event->text_poke.old_len);
  569. event->text_poke.new_len = bswap_16(event->text_poke.new_len);
  570. if (sample_id_all) {
  571. size_t len = sizeof(event->text_poke.old_len) +
  572. sizeof(event->text_poke.new_len) +
  573. event->text_poke.old_len +
  574. event->text_poke.new_len;
  575. void *data = &event->text_poke.old_len;
  576. data += PERF_ALIGN(len, sizeof(u64));
  577. swap_sample_id_all(event, data);
  578. }
  579. }
  580. static void perf_event__throttle_swap(union perf_event *event,
  581. bool sample_id_all)
  582. {
  583. event->throttle.time = bswap_64(event->throttle.time);
  584. event->throttle.id = bswap_64(event->throttle.id);
  585. event->throttle.stream_id = bswap_64(event->throttle.stream_id);
  586. if (sample_id_all)
  587. swap_sample_id_all(event, &event->throttle + 1);
  588. }
  589. static void perf_event__namespaces_swap(union perf_event *event,
  590. bool sample_id_all)
  591. {
  592. u64 i;
  593. event->namespaces.pid = bswap_32(event->namespaces.pid);
  594. event->namespaces.tid = bswap_32(event->namespaces.tid);
  595. event->namespaces.nr_namespaces = bswap_64(event->namespaces.nr_namespaces);
  596. for (i = 0; i < event->namespaces.nr_namespaces; i++) {
  597. struct perf_ns_link_info *ns = &event->namespaces.link_info[i];
  598. ns->dev = bswap_64(ns->dev);
  599. ns->ino = bswap_64(ns->ino);
  600. }
  601. if (sample_id_all)
  602. swap_sample_id_all(event, &event->namespaces.link_info[i]);
  603. }
  604. static void perf_event__cgroup_swap(union perf_event *event, bool sample_id_all)
  605. {
  606. event->cgroup.id = bswap_64(event->cgroup.id);
  607. if (sample_id_all) {
  608. void *data = &event->cgroup.path;
  609. data += PERF_ALIGN(strlen(data) + 1, sizeof(u64));
  610. swap_sample_id_all(event, data);
  611. }
  612. }
  613. static u8 revbyte(u8 b)
  614. {
  615. int rev = (b >> 4) | ((b & 0xf) << 4);
  616. rev = ((rev & 0xcc) >> 2) | ((rev & 0x33) << 2);
  617. rev = ((rev & 0xaa) >> 1) | ((rev & 0x55) << 1);
  618. return (u8) rev;
  619. }
  620. /*
  621. * XXX this is hack in attempt to carry flags bitfield
  622. * through endian village. ABI says:
  623. *
  624. * Bit-fields are allocated from right to left (least to most significant)
  625. * on little-endian implementations and from left to right (most to least
  626. * significant) on big-endian implementations.
  627. *
  628. * The above seems to be byte specific, so we need to reverse each
  629. * byte of the bitfield. 'Internet' also says this might be implementation
  630. * specific and we probably need proper fix and carry perf_event_attr
  631. * bitfield flags in separate data file FEAT_ section. Thought this seems
  632. * to work for now.
  633. */
  634. static void swap_bitfield(u8 *p, unsigned len)
  635. {
  636. unsigned i;
  637. for (i = 0; i < len; i++) {
  638. *p = revbyte(*p);
  639. p++;
  640. }
  641. }
  642. /* exported for swapping attributes in file header */
  643. void perf_event__attr_swap(struct perf_event_attr *attr)
  644. {
  645. attr->type = bswap_32(attr->type);
  646. attr->size = bswap_32(attr->size);
  647. #define bswap_safe(f, n) \
  648. (attr->size > (offsetof(struct perf_event_attr, f) + \
  649. sizeof(attr->f) * (n)))
  650. #define bswap_field(f, sz) \
  651. do { \
  652. if (bswap_safe(f, 0)) \
  653. attr->f = bswap_##sz(attr->f); \
  654. } while(0)
  655. #define bswap_field_16(f) bswap_field(f, 16)
  656. #define bswap_field_32(f) bswap_field(f, 32)
  657. #define bswap_field_64(f) bswap_field(f, 64)
  658. bswap_field_64(config);
  659. bswap_field_64(sample_period);
  660. bswap_field_64(sample_type);
  661. bswap_field_64(read_format);
  662. bswap_field_32(wakeup_events);
  663. bswap_field_32(bp_type);
  664. bswap_field_64(bp_addr);
  665. bswap_field_64(bp_len);
  666. bswap_field_64(branch_sample_type);
  667. bswap_field_64(sample_regs_user);
  668. bswap_field_32(sample_stack_user);
  669. bswap_field_32(aux_watermark);
  670. bswap_field_16(sample_max_stack);
  671. bswap_field_32(aux_sample_size);
  672. /*
  673. * After read_format are bitfields. Check read_format because
  674. * we are unable to use offsetof on bitfield.
  675. */
  676. if (bswap_safe(read_format, 1))
  677. swap_bitfield((u8 *) (&attr->read_format + 1),
  678. sizeof(u64));
  679. #undef bswap_field_64
  680. #undef bswap_field_32
  681. #undef bswap_field
  682. #undef bswap_safe
  683. }
  684. static void perf_event__hdr_attr_swap(union perf_event *event,
  685. bool sample_id_all __maybe_unused)
  686. {
  687. size_t size;
  688. perf_event__attr_swap(&event->attr.attr);
  689. size = event->header.size;
  690. size -= (void *)&event->attr.id - (void *)event;
  691. mem_bswap_64(event->attr.id, size);
  692. }
  693. static void perf_event__event_update_swap(union perf_event *event,
  694. bool sample_id_all __maybe_unused)
  695. {
  696. event->event_update.type = bswap_64(event->event_update.type);
  697. event->event_update.id = bswap_64(event->event_update.id);
  698. }
  699. static void perf_event__event_type_swap(union perf_event *event,
  700. bool sample_id_all __maybe_unused)
  701. {
  702. event->event_type.event_type.event_id =
  703. bswap_64(event->event_type.event_type.event_id);
  704. }
  705. static void perf_event__tracing_data_swap(union perf_event *event,
  706. bool sample_id_all __maybe_unused)
  707. {
  708. event->tracing_data.size = bswap_32(event->tracing_data.size);
  709. }
  710. static void perf_event__auxtrace_info_swap(union perf_event *event,
  711. bool sample_id_all __maybe_unused)
  712. {
  713. size_t size;
  714. event->auxtrace_info.type = bswap_32(event->auxtrace_info.type);
  715. size = event->header.size;
  716. size -= (void *)&event->auxtrace_info.priv - (void *)event;
  717. mem_bswap_64(event->auxtrace_info.priv, size);
  718. }
  719. static void perf_event__auxtrace_swap(union perf_event *event,
  720. bool sample_id_all __maybe_unused)
  721. {
  722. event->auxtrace.size = bswap_64(event->auxtrace.size);
  723. event->auxtrace.offset = bswap_64(event->auxtrace.offset);
  724. event->auxtrace.reference = bswap_64(event->auxtrace.reference);
  725. event->auxtrace.idx = bswap_32(event->auxtrace.idx);
  726. event->auxtrace.tid = bswap_32(event->auxtrace.tid);
  727. event->auxtrace.cpu = bswap_32(event->auxtrace.cpu);
  728. }
  729. static void perf_event__auxtrace_error_swap(union perf_event *event,
  730. bool sample_id_all __maybe_unused)
  731. {
  732. event->auxtrace_error.type = bswap_32(event->auxtrace_error.type);
  733. event->auxtrace_error.code = bswap_32(event->auxtrace_error.code);
  734. event->auxtrace_error.cpu = bswap_32(event->auxtrace_error.cpu);
  735. event->auxtrace_error.pid = bswap_32(event->auxtrace_error.pid);
  736. event->auxtrace_error.tid = bswap_32(event->auxtrace_error.tid);
  737. event->auxtrace_error.fmt = bswap_32(event->auxtrace_error.fmt);
  738. event->auxtrace_error.ip = bswap_64(event->auxtrace_error.ip);
  739. if (event->auxtrace_error.fmt)
  740. event->auxtrace_error.time = bswap_64(event->auxtrace_error.time);
  741. }
  742. static void perf_event__thread_map_swap(union perf_event *event,
  743. bool sample_id_all __maybe_unused)
  744. {
  745. unsigned i;
  746. event->thread_map.nr = bswap_64(event->thread_map.nr);
  747. for (i = 0; i < event->thread_map.nr; i++)
  748. event->thread_map.entries[i].pid = bswap_64(event->thread_map.entries[i].pid);
  749. }
  750. static void perf_event__cpu_map_swap(union perf_event *event,
  751. bool sample_id_all __maybe_unused)
  752. {
  753. struct perf_record_cpu_map_data *data = &event->cpu_map.data;
  754. struct cpu_map_entries *cpus;
  755. struct perf_record_record_cpu_map *mask;
  756. unsigned i;
  757. data->type = bswap_64(data->type);
  758. switch (data->type) {
  759. case PERF_CPU_MAP__CPUS:
  760. cpus = (struct cpu_map_entries *)data->data;
  761. cpus->nr = bswap_16(cpus->nr);
  762. for (i = 0; i < cpus->nr; i++)
  763. cpus->cpu[i] = bswap_16(cpus->cpu[i]);
  764. break;
  765. case PERF_CPU_MAP__MASK:
  766. mask = (struct perf_record_record_cpu_map *)data->data;
  767. mask->nr = bswap_16(mask->nr);
  768. mask->long_size = bswap_16(mask->long_size);
  769. switch (mask->long_size) {
  770. case 4: mem_bswap_32(&mask->mask, mask->nr); break;
  771. case 8: mem_bswap_64(&mask->mask, mask->nr); break;
  772. default:
  773. pr_err("cpu_map swap: unsupported long size\n");
  774. }
  775. default:
  776. break;
  777. }
  778. }
  779. static void perf_event__stat_config_swap(union perf_event *event,
  780. bool sample_id_all __maybe_unused)
  781. {
  782. u64 size;
  783. size = event->stat_config.nr * sizeof(event->stat_config.data[0]);
  784. size += 1; /* nr item itself */
  785. mem_bswap_64(&event->stat_config.nr, size);
  786. }
  787. static void perf_event__stat_swap(union perf_event *event,
  788. bool sample_id_all __maybe_unused)
  789. {
  790. event->stat.id = bswap_64(event->stat.id);
  791. event->stat.thread = bswap_32(event->stat.thread);
  792. event->stat.cpu = bswap_32(event->stat.cpu);
  793. event->stat.val = bswap_64(event->stat.val);
  794. event->stat.ena = bswap_64(event->stat.ena);
  795. event->stat.run = bswap_64(event->stat.run);
  796. }
  797. static void perf_event__stat_round_swap(union perf_event *event,
  798. bool sample_id_all __maybe_unused)
  799. {
  800. event->stat_round.type = bswap_64(event->stat_round.type);
  801. event->stat_round.time = bswap_64(event->stat_round.time);
  802. }
  803. static void perf_event__time_conv_swap(union perf_event *event,
  804. bool sample_id_all __maybe_unused)
  805. {
  806. event->time_conv.time_shift = bswap_64(event->time_conv.time_shift);
  807. event->time_conv.time_mult = bswap_64(event->time_conv.time_mult);
  808. event->time_conv.time_zero = bswap_64(event->time_conv.time_zero);
  809. if (event_contains(event->time_conv, time_cycles)) {
  810. event->time_conv.time_cycles = bswap_64(event->time_conv.time_cycles);
  811. event->time_conv.time_mask = bswap_64(event->time_conv.time_mask);
  812. }
  813. }
  814. typedef void (*perf_event__swap_op)(union perf_event *event,
  815. bool sample_id_all);
  816. static perf_event__swap_op perf_event__swap_ops[] = {
  817. [PERF_RECORD_MMAP] = perf_event__mmap_swap,
  818. [PERF_RECORD_MMAP2] = perf_event__mmap2_swap,
  819. [PERF_RECORD_COMM] = perf_event__comm_swap,
  820. [PERF_RECORD_FORK] = perf_event__task_swap,
  821. [PERF_RECORD_EXIT] = perf_event__task_swap,
  822. [PERF_RECORD_LOST] = perf_event__all64_swap,
  823. [PERF_RECORD_READ] = perf_event__read_swap,
  824. [PERF_RECORD_THROTTLE] = perf_event__throttle_swap,
  825. [PERF_RECORD_UNTHROTTLE] = perf_event__throttle_swap,
  826. [PERF_RECORD_SAMPLE] = perf_event__all64_swap,
  827. [PERF_RECORD_AUX] = perf_event__aux_swap,
  828. [PERF_RECORD_ITRACE_START] = perf_event__itrace_start_swap,
  829. [PERF_RECORD_LOST_SAMPLES] = perf_event__all64_swap,
  830. [PERF_RECORD_SWITCH] = perf_event__switch_swap,
  831. [PERF_RECORD_SWITCH_CPU_WIDE] = perf_event__switch_swap,
  832. [PERF_RECORD_NAMESPACES] = perf_event__namespaces_swap,
  833. [PERF_RECORD_CGROUP] = perf_event__cgroup_swap,
  834. [PERF_RECORD_TEXT_POKE] = perf_event__text_poke_swap,
  835. [PERF_RECORD_HEADER_ATTR] = perf_event__hdr_attr_swap,
  836. [PERF_RECORD_HEADER_EVENT_TYPE] = perf_event__event_type_swap,
  837. [PERF_RECORD_HEADER_TRACING_DATA] = perf_event__tracing_data_swap,
  838. [PERF_RECORD_HEADER_BUILD_ID] = NULL,
  839. [PERF_RECORD_ID_INDEX] = perf_event__all64_swap,
  840. [PERF_RECORD_AUXTRACE_INFO] = perf_event__auxtrace_info_swap,
  841. [PERF_RECORD_AUXTRACE] = perf_event__auxtrace_swap,
  842. [PERF_RECORD_AUXTRACE_ERROR] = perf_event__auxtrace_error_swap,
  843. [PERF_RECORD_THREAD_MAP] = perf_event__thread_map_swap,
  844. [PERF_RECORD_CPU_MAP] = perf_event__cpu_map_swap,
  845. [PERF_RECORD_STAT_CONFIG] = perf_event__stat_config_swap,
  846. [PERF_RECORD_STAT] = perf_event__stat_swap,
  847. [PERF_RECORD_STAT_ROUND] = perf_event__stat_round_swap,
  848. [PERF_RECORD_EVENT_UPDATE] = perf_event__event_update_swap,
  849. [PERF_RECORD_TIME_CONV] = perf_event__time_conv_swap,
  850. [PERF_RECORD_HEADER_MAX] = NULL,
  851. };
  852. /*
  853. * When perf record finishes a pass on every buffers, it records this pseudo
  854. * event.
  855. * We record the max timestamp t found in the pass n.
  856. * Assuming these timestamps are monotonic across cpus, we know that if
  857. * a buffer still has events with timestamps below t, they will be all
  858. * available and then read in the pass n + 1.
  859. * Hence when we start to read the pass n + 2, we can safely flush every
  860. * events with timestamps below t.
  861. *
  862. * ============ PASS n =================
  863. * CPU 0 | CPU 1
  864. * |
  865. * cnt1 timestamps | cnt2 timestamps
  866. * 1 | 2
  867. * 2 | 3
  868. * - | 4 <--- max recorded
  869. *
  870. * ============ PASS n + 1 ==============
  871. * CPU 0 | CPU 1
  872. * |
  873. * cnt1 timestamps | cnt2 timestamps
  874. * 3 | 5
  875. * 4 | 6
  876. * 5 | 7 <---- max recorded
  877. *
  878. * Flush every events below timestamp 4
  879. *
  880. * ============ PASS n + 2 ==============
  881. * CPU 0 | CPU 1
  882. * |
  883. * cnt1 timestamps | cnt2 timestamps
  884. * 6 | 8
  885. * 7 | 9
  886. * - | 10
  887. *
  888. * Flush every events below timestamp 7
  889. * etc...
  890. */
  891. static int process_finished_round(struct perf_tool *tool __maybe_unused,
  892. union perf_event *event __maybe_unused,
  893. struct ordered_events *oe)
  894. {
  895. if (dump_trace)
  896. fprintf(stdout, "\n");
  897. return ordered_events__flush(oe, OE_FLUSH__ROUND);
  898. }
  899. int perf_session__queue_event(struct perf_session *s, union perf_event *event,
  900. u64 timestamp, u64 file_offset)
  901. {
  902. return ordered_events__queue(&s->ordered_events, event, timestamp, file_offset);
  903. }
  904. static void callchain__lbr_callstack_printf(struct perf_sample *sample)
  905. {
  906. struct ip_callchain *callchain = sample->callchain;
  907. struct branch_stack *lbr_stack = sample->branch_stack;
  908. struct branch_entry *entries = perf_sample__branch_entries(sample);
  909. u64 kernel_callchain_nr = callchain->nr;
  910. unsigned int i;
  911. for (i = 0; i < kernel_callchain_nr; i++) {
  912. if (callchain->ips[i] == PERF_CONTEXT_USER)
  913. break;
  914. }
  915. if ((i != kernel_callchain_nr) && lbr_stack->nr) {
  916. u64 total_nr;
  917. /*
  918. * LBR callstack can only get user call chain,
  919. * i is kernel call chain number,
  920. * 1 is PERF_CONTEXT_USER.
  921. *
  922. * The user call chain is stored in LBR registers.
  923. * LBR are pair registers. The caller is stored
  924. * in "from" register, while the callee is stored
  925. * in "to" register.
  926. * For example, there is a call stack
  927. * "A"->"B"->"C"->"D".
  928. * The LBR registers will recorde like
  929. * "C"->"D", "B"->"C", "A"->"B".
  930. * So only the first "to" register and all "from"
  931. * registers are needed to construct the whole stack.
  932. */
  933. total_nr = i + 1 + lbr_stack->nr + 1;
  934. kernel_callchain_nr = i + 1;
  935. printf("... LBR call chain: nr:%" PRIu64 "\n", total_nr);
  936. for (i = 0; i < kernel_callchain_nr; i++)
  937. printf("..... %2d: %016" PRIx64 "\n",
  938. i, callchain->ips[i]);
  939. printf("..... %2d: %016" PRIx64 "\n",
  940. (int)(kernel_callchain_nr), entries[0].to);
  941. for (i = 0; i < lbr_stack->nr; i++)
  942. printf("..... %2d: %016" PRIx64 "\n",
  943. (int)(i + kernel_callchain_nr + 1), entries[i].from);
  944. }
  945. }
  946. static void callchain__printf(struct evsel *evsel,
  947. struct perf_sample *sample)
  948. {
  949. unsigned int i;
  950. struct ip_callchain *callchain = sample->callchain;
  951. if (evsel__has_branch_callstack(evsel))
  952. callchain__lbr_callstack_printf(sample);
  953. printf("... FP chain: nr:%" PRIu64 "\n", callchain->nr);
  954. for (i = 0; i < callchain->nr; i++)
  955. printf("..... %2d: %016" PRIx64 "\n",
  956. i, callchain->ips[i]);
  957. }
  958. static void branch_stack__printf(struct perf_sample *sample, bool callstack)
  959. {
  960. struct branch_entry *entries = perf_sample__branch_entries(sample);
  961. uint64_t i;
  962. printf("%s: nr:%" PRIu64 "\n",
  963. !callstack ? "... branch stack" : "... branch callstack",
  964. sample->branch_stack->nr);
  965. for (i = 0; i < sample->branch_stack->nr; i++) {
  966. struct branch_entry *e = &entries[i];
  967. if (!callstack) {
  968. printf("..... %2"PRIu64": %016" PRIx64 " -> %016" PRIx64 " %hu cycles %s%s%s%s %x\n",
  969. i, e->from, e->to,
  970. (unsigned short)e->flags.cycles,
  971. e->flags.mispred ? "M" : " ",
  972. e->flags.predicted ? "P" : " ",
  973. e->flags.abort ? "A" : " ",
  974. e->flags.in_tx ? "T" : " ",
  975. (unsigned)e->flags.reserved);
  976. } else {
  977. printf("..... %2"PRIu64": %016" PRIx64 "\n",
  978. i, i > 0 ? e->from : e->to);
  979. }
  980. }
  981. }
  982. static void regs_dump__printf(u64 mask, u64 *regs)
  983. {
  984. unsigned rid, i = 0;
  985. for_each_set_bit(rid, (unsigned long *) &mask, sizeof(mask) * 8) {
  986. u64 val = regs[i++];
  987. printf(".... %-5s 0x%016" PRIx64 "\n",
  988. perf_reg_name(rid), val);
  989. }
  990. }
  991. static const char *regs_abi[] = {
  992. [PERF_SAMPLE_REGS_ABI_NONE] = "none",
  993. [PERF_SAMPLE_REGS_ABI_32] = "32-bit",
  994. [PERF_SAMPLE_REGS_ABI_64] = "64-bit",
  995. };
  996. static inline const char *regs_dump_abi(struct regs_dump *d)
  997. {
  998. if (d->abi > PERF_SAMPLE_REGS_ABI_64)
  999. return "unknown";
  1000. return regs_abi[d->abi];
  1001. }
  1002. static void regs__printf(const char *type, struct regs_dump *regs)
  1003. {
  1004. u64 mask = regs->mask;
  1005. printf("... %s regs: mask 0x%" PRIx64 " ABI %s\n",
  1006. type,
  1007. mask,
  1008. regs_dump_abi(regs));
  1009. regs_dump__printf(mask, regs->regs);
  1010. }
  1011. static void regs_user__printf(struct perf_sample *sample)
  1012. {
  1013. struct regs_dump *user_regs = &sample->user_regs;
  1014. if (user_regs->regs)
  1015. regs__printf("user", user_regs);
  1016. }
  1017. static void regs_intr__printf(struct perf_sample *sample)
  1018. {
  1019. struct regs_dump *intr_regs = &sample->intr_regs;
  1020. if (intr_regs->regs)
  1021. regs__printf("intr", intr_regs);
  1022. }
  1023. static void stack_user__printf(struct stack_dump *dump)
  1024. {
  1025. printf("... ustack: size %" PRIu64 ", offset 0x%x\n",
  1026. dump->size, dump->offset);
  1027. }
  1028. static void perf_evlist__print_tstamp(struct evlist *evlist,
  1029. union perf_event *event,
  1030. struct perf_sample *sample)
  1031. {
  1032. u64 sample_type = __evlist__combined_sample_type(evlist);
  1033. if (event->header.type != PERF_RECORD_SAMPLE &&
  1034. !evlist__sample_id_all(evlist)) {
  1035. fputs("-1 -1 ", stdout);
  1036. return;
  1037. }
  1038. if ((sample_type & PERF_SAMPLE_CPU))
  1039. printf("%u ", sample->cpu);
  1040. if (sample_type & PERF_SAMPLE_TIME)
  1041. printf("%" PRIu64 " ", sample->time);
  1042. }
  1043. static void sample_read__printf(struct perf_sample *sample, u64 read_format)
  1044. {
  1045. printf("... sample_read:\n");
  1046. if (read_format & PERF_FORMAT_TOTAL_TIME_ENABLED)
  1047. printf("...... time enabled %016" PRIx64 "\n",
  1048. sample->read.time_enabled);
  1049. if (read_format & PERF_FORMAT_TOTAL_TIME_RUNNING)
  1050. printf("...... time running %016" PRIx64 "\n",
  1051. sample->read.time_running);
  1052. if (read_format & PERF_FORMAT_GROUP) {
  1053. u64 i;
  1054. printf(".... group nr %" PRIu64 "\n", sample->read.group.nr);
  1055. for (i = 0; i < sample->read.group.nr; i++) {
  1056. struct sample_read_value *value;
  1057. value = &sample->read.group.values[i];
  1058. printf("..... id %016" PRIx64
  1059. ", value %016" PRIx64 "\n",
  1060. value->id, value->value);
  1061. }
  1062. } else
  1063. printf("..... id %016" PRIx64 ", value %016" PRIx64 "\n",
  1064. sample->read.one.id, sample->read.one.value);
  1065. }
  1066. static void dump_event(struct evlist *evlist, union perf_event *event,
  1067. u64 file_offset, struct perf_sample *sample)
  1068. {
  1069. if (!dump_trace)
  1070. return;
  1071. printf("\n%#" PRIx64 " [%#x]: event: %d\n",
  1072. file_offset, event->header.size, event->header.type);
  1073. trace_event(event);
  1074. if (event->header.type == PERF_RECORD_SAMPLE && evlist->trace_event_sample_raw)
  1075. evlist->trace_event_sample_raw(evlist, event, sample);
  1076. if (sample)
  1077. perf_evlist__print_tstamp(evlist, event, sample);
  1078. printf("%#" PRIx64 " [%#x]: PERF_RECORD_%s", file_offset,
  1079. event->header.size, perf_event__name(event->header.type));
  1080. }
  1081. static void dump_sample(struct evsel *evsel, union perf_event *event,
  1082. struct perf_sample *sample)
  1083. {
  1084. u64 sample_type;
  1085. if (!dump_trace)
  1086. return;
  1087. printf("(IP, 0x%x): %d/%d: %#" PRIx64 " period: %" PRIu64 " addr: %#" PRIx64 "\n",
  1088. event->header.misc, sample->pid, sample->tid, sample->ip,
  1089. sample->period, sample->addr);
  1090. sample_type = evsel->core.attr.sample_type;
  1091. if (evsel__has_callchain(evsel))
  1092. callchain__printf(evsel, sample);
  1093. if (evsel__has_br_stack(evsel))
  1094. branch_stack__printf(sample, evsel__has_branch_callstack(evsel));
  1095. if (sample_type & PERF_SAMPLE_REGS_USER)
  1096. regs_user__printf(sample);
  1097. if (sample_type & PERF_SAMPLE_REGS_INTR)
  1098. regs_intr__printf(sample);
  1099. if (sample_type & PERF_SAMPLE_STACK_USER)
  1100. stack_user__printf(&sample->user_stack);
  1101. if (sample_type & PERF_SAMPLE_WEIGHT)
  1102. printf("... weight: %" PRIu64 "\n", sample->weight);
  1103. if (sample_type & PERF_SAMPLE_DATA_SRC)
  1104. printf(" . data_src: 0x%"PRIx64"\n", sample->data_src);
  1105. if (sample_type & PERF_SAMPLE_PHYS_ADDR)
  1106. printf(" .. phys_addr: 0x%"PRIx64"\n", sample->phys_addr);
  1107. if (sample_type & PERF_SAMPLE_TRANSACTION)
  1108. printf("... transaction: %" PRIx64 "\n", sample->transaction);
  1109. if (sample_type & PERF_SAMPLE_READ)
  1110. sample_read__printf(sample, evsel->core.attr.read_format);
  1111. }
  1112. static void dump_read(struct evsel *evsel, union perf_event *event)
  1113. {
  1114. struct perf_record_read *read_event = &event->read;
  1115. u64 read_format;
  1116. if (!dump_trace)
  1117. return;
  1118. printf(": %d %d %s %" PRI_lu64 "\n", event->read.pid, event->read.tid,
  1119. evsel__name(evsel), event->read.value);
  1120. if (!evsel)
  1121. return;
  1122. read_format = evsel->core.attr.read_format;
  1123. if (read_format & PERF_FORMAT_TOTAL_TIME_ENABLED)
  1124. printf("... time enabled : %" PRI_lu64 "\n", read_event->time_enabled);
  1125. if (read_format & PERF_FORMAT_TOTAL_TIME_RUNNING)
  1126. printf("... time running : %" PRI_lu64 "\n", read_event->time_running);
  1127. if (read_format & PERF_FORMAT_ID)
  1128. printf("... id : %" PRI_lu64 "\n", read_event->id);
  1129. }
  1130. static struct machine *machines__find_for_cpumode(struct machines *machines,
  1131. union perf_event *event,
  1132. struct perf_sample *sample)
  1133. {
  1134. struct machine *machine;
  1135. if (perf_guest &&
  1136. ((sample->cpumode == PERF_RECORD_MISC_GUEST_KERNEL) ||
  1137. (sample->cpumode == PERF_RECORD_MISC_GUEST_USER))) {
  1138. u32 pid;
  1139. if (event->header.type == PERF_RECORD_MMAP
  1140. || event->header.type == PERF_RECORD_MMAP2)
  1141. pid = event->mmap.pid;
  1142. else
  1143. pid = sample->pid;
  1144. machine = machines__find(machines, pid);
  1145. if (!machine)
  1146. machine = machines__findnew(machines, DEFAULT_GUEST_KERNEL_ID);
  1147. return machine;
  1148. }
  1149. return &machines->host;
  1150. }
  1151. static int deliver_sample_value(struct evlist *evlist,
  1152. struct perf_tool *tool,
  1153. union perf_event *event,
  1154. struct perf_sample *sample,
  1155. struct sample_read_value *v,
  1156. struct machine *machine)
  1157. {
  1158. struct perf_sample_id *sid = perf_evlist__id2sid(evlist, v->id);
  1159. struct evsel *evsel;
  1160. if (sid) {
  1161. sample->id = v->id;
  1162. sample->period = v->value - sid->period;
  1163. sid->period = v->value;
  1164. }
  1165. if (!sid || sid->evsel == NULL) {
  1166. ++evlist->stats.nr_unknown_id;
  1167. return 0;
  1168. }
  1169. /*
  1170. * There's no reason to deliver sample
  1171. * for zero period, bail out.
  1172. */
  1173. if (!sample->period)
  1174. return 0;
  1175. evsel = container_of(sid->evsel, struct evsel, core);
  1176. return tool->sample(tool, event, sample, evsel, machine);
  1177. }
  1178. static int deliver_sample_group(struct evlist *evlist,
  1179. struct perf_tool *tool,
  1180. union perf_event *event,
  1181. struct perf_sample *sample,
  1182. struct machine *machine)
  1183. {
  1184. int ret = -EINVAL;
  1185. u64 i;
  1186. for (i = 0; i < sample->read.group.nr; i++) {
  1187. ret = deliver_sample_value(evlist, tool, event, sample,
  1188. &sample->read.group.values[i],
  1189. machine);
  1190. if (ret)
  1191. break;
  1192. }
  1193. return ret;
  1194. }
  1195. static int
  1196. perf_evlist__deliver_sample(struct evlist *evlist,
  1197. struct perf_tool *tool,
  1198. union perf_event *event,
  1199. struct perf_sample *sample,
  1200. struct evsel *evsel,
  1201. struct machine *machine)
  1202. {
  1203. /* We know evsel != NULL. */
  1204. u64 sample_type = evsel->core.attr.sample_type;
  1205. u64 read_format = evsel->core.attr.read_format;
  1206. /* Standard sample delivery. */
  1207. if (!(sample_type & PERF_SAMPLE_READ))
  1208. return tool->sample(tool, event, sample, evsel, machine);
  1209. /* For PERF_SAMPLE_READ we have either single or group mode. */
  1210. if (read_format & PERF_FORMAT_GROUP)
  1211. return deliver_sample_group(evlist, tool, event, sample,
  1212. machine);
  1213. else
  1214. return deliver_sample_value(evlist, tool, event, sample,
  1215. &sample->read.one, machine);
  1216. }
  1217. static int machines__deliver_event(struct machines *machines,
  1218. struct evlist *evlist,
  1219. union perf_event *event,
  1220. struct perf_sample *sample,
  1221. struct perf_tool *tool, u64 file_offset)
  1222. {
  1223. struct evsel *evsel;
  1224. struct machine *machine;
  1225. dump_event(evlist, event, file_offset, sample);
  1226. evsel = perf_evlist__id2evsel(evlist, sample->id);
  1227. machine = machines__find_for_cpumode(machines, event, sample);
  1228. switch (event->header.type) {
  1229. case PERF_RECORD_SAMPLE:
  1230. if (evsel == NULL) {
  1231. ++evlist->stats.nr_unknown_id;
  1232. return 0;
  1233. }
  1234. dump_sample(evsel, event, sample);
  1235. if (machine == NULL) {
  1236. ++evlist->stats.nr_unprocessable_samples;
  1237. return 0;
  1238. }
  1239. return perf_evlist__deliver_sample(evlist, tool, event, sample, evsel, machine);
  1240. case PERF_RECORD_MMAP:
  1241. return tool->mmap(tool, event, sample, machine);
  1242. case PERF_RECORD_MMAP2:
  1243. if (event->header.misc & PERF_RECORD_MISC_PROC_MAP_PARSE_TIMEOUT)
  1244. ++evlist->stats.nr_proc_map_timeout;
  1245. return tool->mmap2(tool, event, sample, machine);
  1246. case PERF_RECORD_COMM:
  1247. return tool->comm(tool, event, sample, machine);
  1248. case PERF_RECORD_NAMESPACES:
  1249. return tool->namespaces(tool, event, sample, machine);
  1250. case PERF_RECORD_CGROUP:
  1251. return tool->cgroup(tool, event, sample, machine);
  1252. case PERF_RECORD_FORK:
  1253. return tool->fork(tool, event, sample, machine);
  1254. case PERF_RECORD_EXIT:
  1255. return tool->exit(tool, event, sample, machine);
  1256. case PERF_RECORD_LOST:
  1257. if (tool->lost == perf_event__process_lost)
  1258. evlist->stats.total_lost += event->lost.lost;
  1259. return tool->lost(tool, event, sample, machine);
  1260. case PERF_RECORD_LOST_SAMPLES:
  1261. if (tool->lost_samples == perf_event__process_lost_samples)
  1262. evlist->stats.total_lost_samples += event->lost_samples.lost;
  1263. return tool->lost_samples(tool, event, sample, machine);
  1264. case PERF_RECORD_READ:
  1265. dump_read(evsel, event);
  1266. return tool->read(tool, event, sample, evsel, machine);
  1267. case PERF_RECORD_THROTTLE:
  1268. return tool->throttle(tool, event, sample, machine);
  1269. case PERF_RECORD_UNTHROTTLE:
  1270. return tool->unthrottle(tool, event, sample, machine);
  1271. case PERF_RECORD_AUX:
  1272. if (tool->aux == perf_event__process_aux) {
  1273. if (event->aux.flags & PERF_AUX_FLAG_TRUNCATED)
  1274. evlist->stats.total_aux_lost += 1;
  1275. if (event->aux.flags & PERF_AUX_FLAG_PARTIAL)
  1276. evlist->stats.total_aux_partial += 1;
  1277. }
  1278. return tool->aux(tool, event, sample, machine);
  1279. case PERF_RECORD_ITRACE_START:
  1280. return tool->itrace_start(tool, event, sample, machine);
  1281. case PERF_RECORD_SWITCH:
  1282. case PERF_RECORD_SWITCH_CPU_WIDE:
  1283. return tool->context_switch(tool, event, sample, machine);
  1284. case PERF_RECORD_KSYMBOL:
  1285. return tool->ksymbol(tool, event, sample, machine);
  1286. case PERF_RECORD_BPF_EVENT:
  1287. return tool->bpf(tool, event, sample, machine);
  1288. case PERF_RECORD_TEXT_POKE:
  1289. return tool->text_poke(tool, event, sample, machine);
  1290. default:
  1291. ++evlist->stats.nr_unknown_events;
  1292. return -1;
  1293. }
  1294. }
  1295. static int perf_session__deliver_event(struct perf_session *session,
  1296. union perf_event *event,
  1297. struct perf_tool *tool,
  1298. u64 file_offset)
  1299. {
  1300. struct perf_sample sample;
  1301. int ret;
  1302. ret = perf_evlist__parse_sample(session->evlist, event, &sample);
  1303. if (ret) {
  1304. pr_err("Can't parse sample, err = %d\n", ret);
  1305. return ret;
  1306. }
  1307. ret = auxtrace__process_event(session, event, &sample, tool);
  1308. if (ret < 0)
  1309. return ret;
  1310. if (ret > 0)
  1311. return 0;
  1312. ret = machines__deliver_event(&session->machines, session->evlist,
  1313. event, &sample, tool, file_offset);
  1314. if (dump_trace && sample.aux_sample.size)
  1315. auxtrace__dump_auxtrace_sample(session, &sample);
  1316. return ret;
  1317. }
  1318. static s64 perf_session__process_user_event(struct perf_session *session,
  1319. union perf_event *event,
  1320. u64 file_offset)
  1321. {
  1322. struct ordered_events *oe = &session->ordered_events;
  1323. struct perf_tool *tool = session->tool;
  1324. struct perf_sample sample = { .time = 0, };
  1325. int fd = perf_data__fd(session->data);
  1326. int err;
  1327. if (event->header.type != PERF_RECORD_COMPRESSED ||
  1328. tool->compressed == perf_session__process_compressed_event_stub)
  1329. dump_event(session->evlist, event, file_offset, &sample);
  1330. /* These events are processed right away */
  1331. switch (event->header.type) {
  1332. case PERF_RECORD_HEADER_ATTR:
  1333. err = tool->attr(tool, event, &session->evlist);
  1334. if (err == 0) {
  1335. perf_session__set_id_hdr_size(session);
  1336. perf_session__set_comm_exec(session);
  1337. }
  1338. return err;
  1339. case PERF_RECORD_EVENT_UPDATE:
  1340. return tool->event_update(tool, event, &session->evlist);
  1341. case PERF_RECORD_HEADER_EVENT_TYPE:
  1342. /*
  1343. * Depreceated, but we need to handle it for sake
  1344. * of old data files create in pipe mode.
  1345. */
  1346. return 0;
  1347. case PERF_RECORD_HEADER_TRACING_DATA:
  1348. /*
  1349. * Setup for reading amidst mmap, but only when we
  1350. * are in 'file' mode. The 'pipe' fd is in proper
  1351. * place already.
  1352. */
  1353. if (!perf_data__is_pipe(session->data))
  1354. lseek(fd, file_offset, SEEK_SET);
  1355. return tool->tracing_data(session, event);
  1356. case PERF_RECORD_HEADER_BUILD_ID:
  1357. return tool->build_id(session, event);
  1358. case PERF_RECORD_FINISHED_ROUND:
  1359. return tool->finished_round(tool, event, oe);
  1360. case PERF_RECORD_ID_INDEX:
  1361. return tool->id_index(session, event);
  1362. case PERF_RECORD_AUXTRACE_INFO:
  1363. return tool->auxtrace_info(session, event);
  1364. case PERF_RECORD_AUXTRACE:
  1365. /* setup for reading amidst mmap */
  1366. lseek(fd, file_offset + event->header.size, SEEK_SET);
  1367. return tool->auxtrace(session, event);
  1368. case PERF_RECORD_AUXTRACE_ERROR:
  1369. perf_session__auxtrace_error_inc(session, event);
  1370. return tool->auxtrace_error(session, event);
  1371. case PERF_RECORD_THREAD_MAP:
  1372. return tool->thread_map(session, event);
  1373. case PERF_RECORD_CPU_MAP:
  1374. return tool->cpu_map(session, event);
  1375. case PERF_RECORD_STAT_CONFIG:
  1376. return tool->stat_config(session, event);
  1377. case PERF_RECORD_STAT:
  1378. return tool->stat(session, event);
  1379. case PERF_RECORD_STAT_ROUND:
  1380. return tool->stat_round(session, event);
  1381. case PERF_RECORD_TIME_CONV:
  1382. session->time_conv = event->time_conv;
  1383. return tool->time_conv(session, event);
  1384. case PERF_RECORD_HEADER_FEATURE:
  1385. return tool->feature(session, event);
  1386. case PERF_RECORD_COMPRESSED:
  1387. err = tool->compressed(session, event, file_offset);
  1388. if (err)
  1389. dump_event(session->evlist, event, file_offset, &sample);
  1390. return err;
  1391. default:
  1392. return -EINVAL;
  1393. }
  1394. }
  1395. int perf_session__deliver_synth_event(struct perf_session *session,
  1396. union perf_event *event,
  1397. struct perf_sample *sample)
  1398. {
  1399. struct evlist *evlist = session->evlist;
  1400. struct perf_tool *tool = session->tool;
  1401. events_stats__inc(&evlist->stats, event->header.type);
  1402. if (event->header.type >= PERF_RECORD_USER_TYPE_START)
  1403. return perf_session__process_user_event(session, event, 0);
  1404. return machines__deliver_event(&session->machines, evlist, event, sample, tool, 0);
  1405. }
  1406. static void event_swap(union perf_event *event, bool sample_id_all)
  1407. {
  1408. perf_event__swap_op swap;
  1409. swap = perf_event__swap_ops[event->header.type];
  1410. if (swap)
  1411. swap(event, sample_id_all);
  1412. }
  1413. int perf_session__peek_event(struct perf_session *session, off_t file_offset,
  1414. void *buf, size_t buf_sz,
  1415. union perf_event **event_ptr,
  1416. struct perf_sample *sample)
  1417. {
  1418. union perf_event *event;
  1419. size_t hdr_sz, rest;
  1420. int fd;
  1421. if (session->one_mmap && !session->header.needs_swap) {
  1422. event = file_offset - session->one_mmap_offset +
  1423. session->one_mmap_addr;
  1424. goto out_parse_sample;
  1425. }
  1426. if (perf_data__is_pipe(session->data))
  1427. return -1;
  1428. fd = perf_data__fd(session->data);
  1429. hdr_sz = sizeof(struct perf_event_header);
  1430. if (buf_sz < hdr_sz)
  1431. return -1;
  1432. if (lseek(fd, file_offset, SEEK_SET) == (off_t)-1 ||
  1433. readn(fd, buf, hdr_sz) != (ssize_t)hdr_sz)
  1434. return -1;
  1435. event = (union perf_event *)buf;
  1436. if (session->header.needs_swap)
  1437. perf_event_header__bswap(&event->header);
  1438. if (event->header.size < hdr_sz || event->header.size > buf_sz)
  1439. return -1;
  1440. buf += hdr_sz;
  1441. rest = event->header.size - hdr_sz;
  1442. if (readn(fd, buf, rest) != (ssize_t)rest)
  1443. return -1;
  1444. if (session->header.needs_swap)
  1445. event_swap(event, evlist__sample_id_all(session->evlist));
  1446. out_parse_sample:
  1447. if (sample && event->header.type < PERF_RECORD_USER_TYPE_START &&
  1448. perf_evlist__parse_sample(session->evlist, event, sample))
  1449. return -1;
  1450. *event_ptr = event;
  1451. return 0;
  1452. }
  1453. int perf_session__peek_events(struct perf_session *session, u64 offset,
  1454. u64 size, peek_events_cb_t cb, void *data)
  1455. {
  1456. u64 max_offset = offset + size;
  1457. char buf[PERF_SAMPLE_MAX_SIZE];
  1458. union perf_event *event;
  1459. int err;
  1460. do {
  1461. err = perf_session__peek_event(session, offset, buf,
  1462. PERF_SAMPLE_MAX_SIZE, &event,
  1463. NULL);
  1464. if (err)
  1465. return err;
  1466. err = cb(session, event, offset, data);
  1467. if (err)
  1468. return err;
  1469. offset += event->header.size;
  1470. if (event->header.type == PERF_RECORD_AUXTRACE)
  1471. offset += event->auxtrace.size;
  1472. } while (offset < max_offset);
  1473. return err;
  1474. }
  1475. static s64 perf_session__process_event(struct perf_session *session,
  1476. union perf_event *event, u64 file_offset)
  1477. {
  1478. struct evlist *evlist = session->evlist;
  1479. struct perf_tool *tool = session->tool;
  1480. int ret;
  1481. if (session->header.needs_swap)
  1482. event_swap(event, evlist__sample_id_all(evlist));
  1483. if (event->header.type >= PERF_RECORD_HEADER_MAX)
  1484. return -EINVAL;
  1485. events_stats__inc(&evlist->stats, event->header.type);
  1486. if (event->header.type >= PERF_RECORD_USER_TYPE_START)
  1487. return perf_session__process_user_event(session, event, file_offset);
  1488. if (tool->ordered_events) {
  1489. u64 timestamp = -1ULL;
  1490. ret = perf_evlist__parse_sample_timestamp(evlist, event, &timestamp);
  1491. if (ret && ret != -1)
  1492. return ret;
  1493. ret = perf_session__queue_event(session, event, timestamp, file_offset);
  1494. if (ret != -ETIME)
  1495. return ret;
  1496. }
  1497. return perf_session__deliver_event(session, event, tool, file_offset);
  1498. }
  1499. void perf_event_header__bswap(struct perf_event_header *hdr)
  1500. {
  1501. hdr->type = bswap_32(hdr->type);
  1502. hdr->misc = bswap_16(hdr->misc);
  1503. hdr->size = bswap_16(hdr->size);
  1504. }
  1505. struct thread *perf_session__findnew(struct perf_session *session, pid_t pid)
  1506. {
  1507. return machine__findnew_thread(&session->machines.host, -1, pid);
  1508. }
  1509. /*
  1510. * Threads are identified by pid and tid, and the idle task has pid == tid == 0.
  1511. * So here a single thread is created for that, but actually there is a separate
  1512. * idle task per cpu, so there should be one 'struct thread' per cpu, but there
  1513. * is only 1. That causes problems for some tools, requiring workarounds. For
  1514. * example get_idle_thread() in builtin-sched.c, or thread_stack__per_cpu().
  1515. */
  1516. int perf_session__register_idle_thread(struct perf_session *session)
  1517. {
  1518. struct thread *thread;
  1519. int err = 0;
  1520. thread = machine__findnew_thread(&session->machines.host, 0, 0);
  1521. if (thread == NULL || thread__set_comm(thread, "swapper", 0)) {
  1522. pr_err("problem inserting idle task.\n");
  1523. err = -1;
  1524. }
  1525. if (thread == NULL || thread__set_namespaces(thread, 0, NULL)) {
  1526. pr_err("problem inserting idle task.\n");
  1527. err = -1;
  1528. }
  1529. /* machine__findnew_thread() got the thread, so put it */
  1530. thread__put(thread);
  1531. return err;
  1532. }
  1533. static void
  1534. perf_session__warn_order(const struct perf_session *session)
  1535. {
  1536. const struct ordered_events *oe = &session->ordered_events;
  1537. struct evsel *evsel;
  1538. bool should_warn = true;
  1539. evlist__for_each_entry(session->evlist, evsel) {
  1540. if (evsel->core.attr.write_backward)
  1541. should_warn = false;
  1542. }
  1543. if (!should_warn)
  1544. return;
  1545. if (oe->nr_unordered_events != 0)
  1546. ui__warning("%u out of order events recorded.\n", oe->nr_unordered_events);
  1547. }
  1548. static void perf_session__warn_about_errors(const struct perf_session *session)
  1549. {
  1550. const struct events_stats *stats = &session->evlist->stats;
  1551. if (session->tool->lost == perf_event__process_lost &&
  1552. stats->nr_events[PERF_RECORD_LOST] != 0) {
  1553. ui__warning("Processed %d events and lost %d chunks!\n\n"
  1554. "Check IO/CPU overload!\n\n",
  1555. stats->nr_events[0],
  1556. stats->nr_events[PERF_RECORD_LOST]);
  1557. }
  1558. if (session->tool->lost_samples == perf_event__process_lost_samples) {
  1559. double drop_rate;
  1560. drop_rate = (double)stats->total_lost_samples /
  1561. (double) (stats->nr_events[PERF_RECORD_SAMPLE] + stats->total_lost_samples);
  1562. if (drop_rate > 0.05) {
  1563. ui__warning("Processed %" PRIu64 " samples and lost %3.2f%%!\n\n",
  1564. stats->nr_events[PERF_RECORD_SAMPLE] + stats->total_lost_samples,
  1565. drop_rate * 100.0);
  1566. }
  1567. }
  1568. if (session->tool->aux == perf_event__process_aux &&
  1569. stats->total_aux_lost != 0) {
  1570. ui__warning("AUX data lost %" PRIu64 " times out of %u!\n\n",
  1571. stats->total_aux_lost,
  1572. stats->nr_events[PERF_RECORD_AUX]);
  1573. }
  1574. if (session->tool->aux == perf_event__process_aux &&
  1575. stats->total_aux_partial != 0) {
  1576. bool vmm_exclusive = false;
  1577. (void)sysfs__read_bool("module/kvm_intel/parameters/vmm_exclusive",
  1578. &vmm_exclusive);
  1579. ui__warning("AUX data had gaps in it %" PRIu64 " times out of %u!\n\n"
  1580. "Are you running a KVM guest in the background?%s\n\n",
  1581. stats->total_aux_partial,
  1582. stats->nr_events[PERF_RECORD_AUX],
  1583. vmm_exclusive ?
  1584. "\nReloading kvm_intel module with vmm_exclusive=0\n"
  1585. "will reduce the gaps to only guest's timeslices." :
  1586. "");
  1587. }
  1588. if (stats->nr_unknown_events != 0) {
  1589. ui__warning("Found %u unknown events!\n\n"
  1590. "Is this an older tool processing a perf.data "
  1591. "file generated by a more recent tool?\n\n"
  1592. "If that is not the case, consider "
  1593. "reporting to linux-kernel@vger.kernel.org.\n\n",
  1594. stats->nr_unknown_events);
  1595. }
  1596. if (stats->nr_unknown_id != 0) {
  1597. ui__warning("%u samples with id not present in the header\n",
  1598. stats->nr_unknown_id);
  1599. }
  1600. if (stats->nr_invalid_chains != 0) {
  1601. ui__warning("Found invalid callchains!\n\n"
  1602. "%u out of %u events were discarded for this reason.\n\n"
  1603. "Consider reporting to linux-kernel@vger.kernel.org.\n\n",
  1604. stats->nr_invalid_chains,
  1605. stats->nr_events[PERF_RECORD_SAMPLE]);
  1606. }
  1607. if (stats->nr_unprocessable_samples != 0) {
  1608. ui__warning("%u unprocessable samples recorded.\n"
  1609. "Do you have a KVM guest running and not using 'perf kvm'?\n",
  1610. stats->nr_unprocessable_samples);
  1611. }
  1612. perf_session__warn_order(session);
  1613. events_stats__auxtrace_error_warn(stats);
  1614. if (stats->nr_proc_map_timeout != 0) {
  1615. ui__warning("%d map information files for pre-existing threads were\n"
  1616. "not processed, if there are samples for addresses they\n"
  1617. "will not be resolved, you may find out which are these\n"
  1618. "threads by running with -v and redirecting the output\n"
  1619. "to a file.\n"
  1620. "The time limit to process proc map is too short?\n"
  1621. "Increase it by --proc-map-timeout\n",
  1622. stats->nr_proc_map_timeout);
  1623. }
  1624. }
  1625. static int perf_session__flush_thread_stack(struct thread *thread,
  1626. void *p __maybe_unused)
  1627. {
  1628. return thread_stack__flush(thread);
  1629. }
  1630. static int perf_session__flush_thread_stacks(struct perf_session *session)
  1631. {
  1632. return machines__for_each_thread(&session->machines,
  1633. perf_session__flush_thread_stack,
  1634. NULL);
  1635. }
  1636. volatile int session_done;
  1637. static int __perf_session__process_decomp_events(struct perf_session *session);
  1638. static int __perf_session__process_pipe_events(struct perf_session *session)
  1639. {
  1640. struct ordered_events *oe = &session->ordered_events;
  1641. struct perf_tool *tool = session->tool;
  1642. int fd = perf_data__fd(session->data);
  1643. union perf_event *event;
  1644. uint32_t size, cur_size = 0;
  1645. void *buf = NULL;
  1646. s64 skip = 0;
  1647. u64 head;
  1648. ssize_t err;
  1649. void *p;
  1650. perf_tool__fill_defaults(tool);
  1651. head = 0;
  1652. cur_size = sizeof(union perf_event);
  1653. buf = malloc(cur_size);
  1654. if (!buf)
  1655. return -errno;
  1656. ordered_events__set_copy_on_queue(oe, true);
  1657. more:
  1658. event = buf;
  1659. err = readn(fd, event, sizeof(struct perf_event_header));
  1660. if (err <= 0) {
  1661. if (err == 0)
  1662. goto done;
  1663. pr_err("failed to read event header\n");
  1664. goto out_err;
  1665. }
  1666. if (session->header.needs_swap)
  1667. perf_event_header__bswap(&event->header);
  1668. size = event->header.size;
  1669. if (size < sizeof(struct perf_event_header)) {
  1670. pr_err("bad event header size\n");
  1671. goto out_err;
  1672. }
  1673. if (size > cur_size) {
  1674. void *new = realloc(buf, size);
  1675. if (!new) {
  1676. pr_err("failed to allocate memory to read event\n");
  1677. goto out_err;
  1678. }
  1679. buf = new;
  1680. cur_size = size;
  1681. event = buf;
  1682. }
  1683. p = event;
  1684. p += sizeof(struct perf_event_header);
  1685. if (size - sizeof(struct perf_event_header)) {
  1686. err = readn(fd, p, size - sizeof(struct perf_event_header));
  1687. if (err <= 0) {
  1688. if (err == 0) {
  1689. pr_err("unexpected end of event stream\n");
  1690. goto done;
  1691. }
  1692. pr_err("failed to read event data\n");
  1693. goto out_err;
  1694. }
  1695. }
  1696. if ((skip = perf_session__process_event(session, event, head)) < 0) {
  1697. pr_err("%#" PRIx64 " [%#x]: failed to process type: %d\n",
  1698. head, event->header.size, event->header.type);
  1699. err = -EINVAL;
  1700. goto out_err;
  1701. }
  1702. head += size;
  1703. if (skip > 0)
  1704. head += skip;
  1705. err = __perf_session__process_decomp_events(session);
  1706. if (err)
  1707. goto out_err;
  1708. if (!session_done())
  1709. goto more;
  1710. done:
  1711. /* do the final flush for ordered samples */
  1712. err = ordered_events__flush(oe, OE_FLUSH__FINAL);
  1713. if (err)
  1714. goto out_err;
  1715. err = auxtrace__flush_events(session, tool);
  1716. if (err)
  1717. goto out_err;
  1718. err = perf_session__flush_thread_stacks(session);
  1719. out_err:
  1720. free(buf);
  1721. if (!tool->no_warn)
  1722. perf_session__warn_about_errors(session);
  1723. ordered_events__free(&session->ordered_events);
  1724. auxtrace__free_events(session);
  1725. return err;
  1726. }
  1727. static union perf_event *
  1728. prefetch_event(char *buf, u64 head, size_t mmap_size,
  1729. bool needs_swap, union perf_event *error)
  1730. {
  1731. union perf_event *event;
  1732. u16 event_size;
  1733. /*
  1734. * Ensure we have enough space remaining to read
  1735. * the size of the event in the headers.
  1736. */
  1737. if (head + sizeof(event->header) > mmap_size)
  1738. return NULL;
  1739. event = (union perf_event *)(buf + head);
  1740. if (needs_swap)
  1741. perf_event_header__bswap(&event->header);
  1742. event_size = event->header.size;
  1743. if (head + event_size <= mmap_size)
  1744. return event;
  1745. /* We're not fetching the event so swap back again */
  1746. if (needs_swap)
  1747. perf_event_header__bswap(&event->header);
  1748. /* Check if the event fits into the next mmapped buf. */
  1749. if (event_size <= mmap_size - head % page_size) {
  1750. /* Remap buf and fetch again. */
  1751. return NULL;
  1752. }
  1753. /* Invalid input. Event size should never exceed mmap_size. */
  1754. pr_debug("%s: head=%#" PRIx64 " event->header.size=%#x, mmap_size=%#zx:"
  1755. " fuzzed or compressed perf.data?\n", __func__, head, event_size, mmap_size);
  1756. return error;
  1757. }
  1758. static union perf_event *
  1759. fetch_mmaped_event(u64 head, size_t mmap_size, char *buf, bool needs_swap)
  1760. {
  1761. return prefetch_event(buf, head, mmap_size, needs_swap, ERR_PTR(-EINVAL));
  1762. }
  1763. static union perf_event *
  1764. fetch_decomp_event(u64 head, size_t mmap_size, char *buf, bool needs_swap)
  1765. {
  1766. return prefetch_event(buf, head, mmap_size, needs_swap, NULL);
  1767. }
  1768. static int __perf_session__process_decomp_events(struct perf_session *session)
  1769. {
  1770. s64 skip;
  1771. u64 size, file_pos = 0;
  1772. struct decomp *decomp = session->decomp_last;
  1773. if (!decomp)
  1774. return 0;
  1775. while (decomp->head < decomp->size && !session_done()) {
  1776. union perf_event *event = fetch_decomp_event(decomp->head, decomp->size, decomp->data,
  1777. session->header.needs_swap);
  1778. if (!event)
  1779. break;
  1780. size = event->header.size;
  1781. if (size < sizeof(struct perf_event_header) ||
  1782. (skip = perf_session__process_event(session, event, file_pos)) < 0) {
  1783. pr_err("%#" PRIx64 " [%#x]: failed to process type: %d\n",
  1784. decomp->file_pos + decomp->head, event->header.size, event->header.type);
  1785. return -EINVAL;
  1786. }
  1787. if (skip)
  1788. size += skip;
  1789. decomp->head += size;
  1790. }
  1791. return 0;
  1792. }
  1793. /*
  1794. * On 64bit we can mmap the data file in one go. No need for tiny mmap
  1795. * slices. On 32bit we use 32MB.
  1796. */
  1797. #if BITS_PER_LONG == 64
  1798. #define MMAP_SIZE ULLONG_MAX
  1799. #define NUM_MMAPS 1
  1800. #else
  1801. #define MMAP_SIZE (32 * 1024 * 1024ULL)
  1802. #define NUM_MMAPS 128
  1803. #endif
  1804. struct reader;
  1805. typedef s64 (*reader_cb_t)(struct perf_session *session,
  1806. union perf_event *event,
  1807. u64 file_offset);
  1808. struct reader {
  1809. int fd;
  1810. u64 data_size;
  1811. u64 data_offset;
  1812. reader_cb_t process;
  1813. };
  1814. static int
  1815. reader__process_events(struct reader *rd, struct perf_session *session,
  1816. struct ui_progress *prog)
  1817. {
  1818. u64 data_size = rd->data_size;
  1819. u64 head, page_offset, file_offset, file_pos, size;
  1820. int err = 0, mmap_prot, mmap_flags, map_idx = 0;
  1821. size_t mmap_size;
  1822. char *buf, *mmaps[NUM_MMAPS];
  1823. union perf_event *event;
  1824. s64 skip;
  1825. page_offset = page_size * (rd->data_offset / page_size);
  1826. file_offset = page_offset;
  1827. head = rd->data_offset - page_offset;
  1828. ui_progress__init_size(prog, data_size, "Processing events...");
  1829. data_size += rd->data_offset;
  1830. mmap_size = MMAP_SIZE;
  1831. if (mmap_size > data_size) {
  1832. mmap_size = data_size;
  1833. session->one_mmap = true;
  1834. }
  1835. memset(mmaps, 0, sizeof(mmaps));
  1836. mmap_prot = PROT_READ;
  1837. mmap_flags = MAP_SHARED;
  1838. if (session->header.needs_swap) {
  1839. mmap_prot |= PROT_WRITE;
  1840. mmap_flags = MAP_PRIVATE;
  1841. }
  1842. remap:
  1843. buf = mmap(NULL, mmap_size, mmap_prot, mmap_flags, rd->fd,
  1844. file_offset);
  1845. if (buf == MAP_FAILED) {
  1846. pr_err("failed to mmap file\n");
  1847. err = -errno;
  1848. goto out;
  1849. }
  1850. mmaps[map_idx] = buf;
  1851. map_idx = (map_idx + 1) & (ARRAY_SIZE(mmaps) - 1);
  1852. file_pos = file_offset + head;
  1853. if (session->one_mmap) {
  1854. session->one_mmap_addr = buf;
  1855. session->one_mmap_offset = file_offset;
  1856. }
  1857. more:
  1858. event = fetch_mmaped_event(head, mmap_size, buf, session->header.needs_swap);
  1859. if (IS_ERR(event))
  1860. return PTR_ERR(event);
  1861. if (!event) {
  1862. if (mmaps[map_idx]) {
  1863. munmap(mmaps[map_idx], mmap_size);
  1864. mmaps[map_idx] = NULL;
  1865. }
  1866. page_offset = page_size * (head / page_size);
  1867. file_offset += page_offset;
  1868. head -= page_offset;
  1869. goto remap;
  1870. }
  1871. size = event->header.size;
  1872. skip = -EINVAL;
  1873. if (size < sizeof(struct perf_event_header) ||
  1874. (skip = rd->process(session, event, file_pos)) < 0) {
  1875. pr_err("%#" PRIx64 " [%#x]: failed to process type: %d [%s]\n",
  1876. file_offset + head, event->header.size,
  1877. event->header.type, strerror(-skip));
  1878. err = skip;
  1879. goto out;
  1880. }
  1881. if (skip)
  1882. size += skip;
  1883. head += size;
  1884. file_pos += size;
  1885. err = __perf_session__process_decomp_events(session);
  1886. if (err)
  1887. goto out;
  1888. ui_progress__update(prog, size);
  1889. if (session_done())
  1890. goto out;
  1891. if (file_pos < data_size)
  1892. goto more;
  1893. out:
  1894. return err;
  1895. }
  1896. static s64 process_simple(struct perf_session *session,
  1897. union perf_event *event,
  1898. u64 file_offset)
  1899. {
  1900. return perf_session__process_event(session, event, file_offset);
  1901. }
  1902. static int __perf_session__process_events(struct perf_session *session)
  1903. {
  1904. struct reader rd = {
  1905. .fd = perf_data__fd(session->data),
  1906. .data_size = session->header.data_size,
  1907. .data_offset = session->header.data_offset,
  1908. .process = process_simple,
  1909. };
  1910. struct ordered_events *oe = &session->ordered_events;
  1911. struct perf_tool *tool = session->tool;
  1912. struct ui_progress prog;
  1913. int err;
  1914. perf_tool__fill_defaults(tool);
  1915. if (rd.data_size == 0)
  1916. return -1;
  1917. ui_progress__init_size(&prog, rd.data_size, "Processing events...");
  1918. err = reader__process_events(&rd, session, &prog);
  1919. if (err)
  1920. goto out_err;
  1921. /* do the final flush for ordered samples */
  1922. err = ordered_events__flush(oe, OE_FLUSH__FINAL);
  1923. if (err)
  1924. goto out_err;
  1925. err = auxtrace__flush_events(session, tool);
  1926. if (err)
  1927. goto out_err;
  1928. err = perf_session__flush_thread_stacks(session);
  1929. out_err:
  1930. ui_progress__finish();
  1931. if (!tool->no_warn)
  1932. perf_session__warn_about_errors(session);
  1933. /*
  1934. * We may switching perf.data output, make ordered_events
  1935. * reusable.
  1936. */
  1937. ordered_events__reinit(&session->ordered_events);
  1938. auxtrace__free_events(session);
  1939. session->one_mmap = false;
  1940. return err;
  1941. }
  1942. int perf_session__process_events(struct perf_session *session)
  1943. {
  1944. if (perf_session__register_idle_thread(session) < 0)
  1945. return -ENOMEM;
  1946. if (perf_data__is_pipe(session->data))
  1947. return __perf_session__process_pipe_events(session);
  1948. return __perf_session__process_events(session);
  1949. }
  1950. bool perf_session__has_traces(struct perf_session *session, const char *msg)
  1951. {
  1952. struct evsel *evsel;
  1953. evlist__for_each_entry(session->evlist, evsel) {
  1954. if (evsel->core.attr.type == PERF_TYPE_TRACEPOINT)
  1955. return true;
  1956. }
  1957. pr_err("No trace sample to read. Did you call 'perf %s'?\n", msg);
  1958. return false;
  1959. }
  1960. int map__set_kallsyms_ref_reloc_sym(struct map *map, const char *symbol_name, u64 addr)
  1961. {
  1962. char *bracket;
  1963. struct ref_reloc_sym *ref;
  1964. struct kmap *kmap;
  1965. ref = zalloc(sizeof(struct ref_reloc_sym));
  1966. if (ref == NULL)
  1967. return -ENOMEM;
  1968. ref->name = strdup(symbol_name);
  1969. if (ref->name == NULL) {
  1970. free(ref);
  1971. return -ENOMEM;
  1972. }
  1973. bracket = strchr(ref->name, ']');
  1974. if (bracket)
  1975. *bracket = '\0';
  1976. ref->addr = addr;
  1977. kmap = map__kmap(map);
  1978. if (kmap)
  1979. kmap->ref_reloc_sym = ref;
  1980. return 0;
  1981. }
  1982. size_t perf_session__fprintf_dsos(struct perf_session *session, FILE *fp)
  1983. {
  1984. return machines__fprintf_dsos(&session->machines, fp);
  1985. }
  1986. size_t perf_session__fprintf_dsos_buildid(struct perf_session *session, FILE *fp,
  1987. bool (skip)(struct dso *dso, int parm), int parm)
  1988. {
  1989. return machines__fprintf_dsos_buildid(&session->machines, fp, skip, parm);
  1990. }
  1991. size_t perf_session__fprintf_nr_events(struct perf_session *session, FILE *fp)
  1992. {
  1993. size_t ret;
  1994. const char *msg = "";
  1995. if (perf_header__has_feat(&session->header, HEADER_AUXTRACE))
  1996. msg = " (excludes AUX area (e.g. instruction trace) decoded / synthesized events)";
  1997. ret = fprintf(fp, "\nAggregated stats:%s\n", msg);
  1998. ret += events_stats__fprintf(&session->evlist->stats, fp);
  1999. return ret;
  2000. }
  2001. size_t perf_session__fprintf(struct perf_session *session, FILE *fp)
  2002. {
  2003. /*
  2004. * FIXME: Here we have to actually print all the machines in this
  2005. * session, not just the host...
  2006. */
  2007. return machine__fprintf(&session->machines.host, fp);
  2008. }
  2009. struct evsel *perf_session__find_first_evtype(struct perf_session *session,
  2010. unsigned int type)
  2011. {
  2012. struct evsel *pos;
  2013. evlist__for_each_entry(session->evlist, pos) {
  2014. if (pos->core.attr.type == type)
  2015. return pos;
  2016. }
  2017. return NULL;
  2018. }
  2019. int perf_session__cpu_bitmap(struct perf_session *session,
  2020. const char *cpu_list, unsigned long *cpu_bitmap)
  2021. {
  2022. int i, err = -1;
  2023. struct perf_cpu_map *map;
  2024. int nr_cpus = min(session->header.env.nr_cpus_avail, MAX_NR_CPUS);
  2025. for (i = 0; i < PERF_TYPE_MAX; ++i) {
  2026. struct evsel *evsel;
  2027. evsel = perf_session__find_first_evtype(session, i);
  2028. if (!evsel)
  2029. continue;
  2030. if (!(evsel->core.attr.sample_type & PERF_SAMPLE_CPU)) {
  2031. pr_err("File does not contain CPU events. "
  2032. "Remove -C option to proceed.\n");
  2033. return -1;
  2034. }
  2035. }
  2036. map = perf_cpu_map__new(cpu_list);
  2037. if (map == NULL) {
  2038. pr_err("Invalid cpu_list\n");
  2039. return -1;
  2040. }
  2041. for (i = 0; i < map->nr; i++) {
  2042. int cpu = map->map[i];
  2043. if (cpu >= nr_cpus) {
  2044. pr_err("Requested CPU %d too large. "
  2045. "Consider raising MAX_NR_CPUS\n", cpu);
  2046. goto out_delete_map;
  2047. }
  2048. set_bit(cpu, cpu_bitmap);
  2049. }
  2050. err = 0;
  2051. out_delete_map:
  2052. perf_cpu_map__put(map);
  2053. return err;
  2054. }
  2055. void perf_session__fprintf_info(struct perf_session *session, FILE *fp,
  2056. bool full)
  2057. {
  2058. if (session == NULL || fp == NULL)
  2059. return;
  2060. fprintf(fp, "# ========\n");
  2061. perf_header__fprintf_info(session, fp, full);
  2062. fprintf(fp, "# ========\n#\n");
  2063. }
  2064. int perf_event__process_id_index(struct perf_session *session,
  2065. union perf_event *event)
  2066. {
  2067. struct evlist *evlist = session->evlist;
  2068. struct perf_record_id_index *ie = &event->id_index;
  2069. size_t i, nr, max_nr;
  2070. max_nr = (ie->header.size - sizeof(struct perf_record_id_index)) /
  2071. sizeof(struct id_index_entry);
  2072. nr = ie->nr;
  2073. if (nr > max_nr)
  2074. return -EINVAL;
  2075. if (dump_trace)
  2076. fprintf(stdout, " nr: %zu\n", nr);
  2077. for (i = 0; i < nr; i++) {
  2078. struct id_index_entry *e = &ie->entries[i];
  2079. struct perf_sample_id *sid;
  2080. if (dump_trace) {
  2081. fprintf(stdout, " ... id: %"PRI_lu64, e->id);
  2082. fprintf(stdout, " idx: %"PRI_lu64, e->idx);
  2083. fprintf(stdout, " cpu: %"PRI_ld64, e->cpu);
  2084. fprintf(stdout, " tid: %"PRI_ld64"\n", e->tid);
  2085. }
  2086. sid = perf_evlist__id2sid(evlist, e->id);
  2087. if (!sid)
  2088. return -ENOENT;
  2089. sid->idx = e->idx;
  2090. sid->cpu = e->cpu;
  2091. sid->tid = e->tid;
  2092. }
  2093. return 0;
  2094. }