header.c 54 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095109610971098109911001101110211031104110511061107110811091110111111121113111411151116111711181119112011211122112311241125112611271128112911301131113211331134113511361137113811391140114111421143114411451146114711481149115011511152115311541155115611571158115911601161116211631164116511661167116811691170117111721173117411751176117711781179118011811182118311841185118611871188118911901191119211931194119511961197119811991200120112021203120412051206120712081209121012111212121312141215121612171218121912201221122212231224122512261227122812291230123112321233123412351236123712381239124012411242124312441245124612471248124912501251125212531254125512561257125812591260126112621263126412651266126712681269127012711272127312741275127612771278127912801281128212831284128512861287128812891290129112921293129412951296129712981299130013011302130313041305130613071308130913101311131213131314131513161317131813191320132113221323132413251326132713281329133013311332133313341335133613371338133913401341134213431344134513461347134813491350135113521353135413551356135713581359136013611362136313641365136613671368136913701371137213731374137513761377137813791380138113821383138413851386138713881389139013911392139313941395139613971398139914001401140214031404140514061407140814091410141114121413141414151416141714181419142014211422142314241425142614271428142914301431143214331434143514361437143814391440144114421443144414451446144714481449145014511452145314541455145614571458145914601461146214631464146514661467146814691470147114721473147414751476147714781479148014811482148314841485148614871488148914901491149214931494149514961497149814991500150115021503150415051506150715081509151015111512151315141515151615171518151915201521152215231524152515261527152815291530153115321533153415351536153715381539154015411542154315441545154615471548154915501551155215531554155515561557155815591560156115621563156415651566156715681569157015711572157315741575157615771578157915801581158215831584158515861587158815891590159115921593159415951596159715981599160016011602160316041605160616071608160916101611161216131614161516161617161816191620162116221623162416251626162716281629163016311632163316341635163616371638163916401641164216431644164516461647164816491650165116521653165416551656165716581659166016611662166316641665166616671668166916701671167216731674167516761677167816791680168116821683168416851686168716881689169016911692169316941695169616971698169917001701170217031704170517061707170817091710171117121713171417151716171717181719172017211722172317241725172617271728172917301731173217331734173517361737173817391740174117421743174417451746174717481749175017511752175317541755175617571758175917601761176217631764176517661767176817691770177117721773177417751776177717781779178017811782178317841785178617871788178917901791179217931794179517961797179817991800180118021803180418051806180718081809181018111812181318141815181618171818181918201821182218231824182518261827182818291830183118321833183418351836183718381839184018411842184318441845184618471848184918501851185218531854185518561857185818591860186118621863186418651866186718681869187018711872187318741875187618771878187918801881188218831884188518861887188818891890189118921893189418951896189718981899190019011902190319041905190619071908190919101911191219131914191519161917191819191920192119221923192419251926192719281929193019311932193319341935193619371938193919401941194219431944194519461947194819491950195119521953195419551956195719581959196019611962196319641965196619671968196919701971197219731974197519761977197819791980198119821983198419851986198719881989199019911992199319941995199619971998199920002001200220032004200520062007200820092010201120122013201420152016201720182019202020212022202320242025202620272028202920302031203220332034203520362037203820392040204120422043204420452046204720482049205020512052205320542055205620572058205920602061206220632064206520662067206820692070207120722073207420752076207720782079208020812082208320842085208620872088208920902091209220932094209520962097209820992100210121022103210421052106210721082109211021112112211321142115211621172118211921202121212221232124212521262127212821292130213121322133213421352136213721382139214021412142214321442145214621472148214921502151215221532154215521562157215821592160216121622163216421652166216721682169217021712172217321742175217621772178217921802181218221832184218521862187218821892190219121922193219421952196219721982199220022012202220322042205220622072208220922102211221222132214221522162217221822192220222122222223222422252226222722282229223022312232223322342235223622372238223922402241224222432244224522462247224822492250225122522253225422552256225722582259226022612262226322642265226622672268226922702271227222732274227522762277227822792280228122822283228422852286228722882289229022912292229322942295229622972298229923002301230223032304230523062307230823092310231123122313231423152316231723182319232023212322232323242325232623272328232923302331233223332334233523362337233823392340234123422343234423452346234723482349235023512352235323542355235623572358235923602361236223632364236523662367236823692370237123722373237423752376237723782379238023812382238323842385238623872388238923902391239223932394239523962397239823992400240124022403240424052406240724082409241024112412241324142415241624172418241924202421242224232424242524262427242824292430243124322433243424352436243724382439244024412442244324442445244624472448244924502451245224532454245524562457245824592460246124622463246424652466246724682469247024712472247324742475247624772478247924802481
  1. #define _FILE_OFFSET_BITS 64
  2. #include "util.h"
  3. #include <sys/types.h>
  4. #include <byteswap.h>
  5. #include <unistd.h>
  6. #include <stdio.h>
  7. #include <stdlib.h>
  8. #include <linux/list.h>
  9. #include <linux/kernel.h>
  10. #include <linux/bitops.h>
  11. #include <sys/utsname.h>
  12. #include "evlist.h"
  13. #include "evsel.h"
  14. #include "header.h"
  15. #include "../perf.h"
  16. #include "trace-event.h"
  17. #include "session.h"
  18. #include "symbol.h"
  19. #include "debug.h"
  20. #include "cpumap.h"
  21. static bool no_buildid_cache = false;
  22. static int event_count;
  23. static struct perf_trace_event_type *events;
  24. static u32 header_argc;
  25. static const char **header_argv;
  26. int perf_header__push_event(u64 id, const char *name)
  27. {
  28. struct perf_trace_event_type *nevents;
  29. if (strlen(name) > MAX_EVENT_NAME)
  30. pr_warning("Event %s will be truncated\n", name);
  31. nevents = realloc(events, (event_count + 1) * sizeof(*events));
  32. if (nevents == NULL)
  33. return -ENOMEM;
  34. events = nevents;
  35. memset(&events[event_count], 0, sizeof(struct perf_trace_event_type));
  36. events[event_count].event_id = id;
  37. strncpy(events[event_count].name, name, MAX_EVENT_NAME - 1);
  38. event_count++;
  39. return 0;
  40. }
  41. char *perf_header__find_event(u64 id)
  42. {
  43. int i;
  44. for (i = 0 ; i < event_count; i++) {
  45. if (events[i].event_id == id)
  46. return events[i].name;
  47. }
  48. return NULL;
  49. }
  50. /*
  51. * magic2 = "PERFILE2"
  52. * must be a numerical value to let the endianness
  53. * determine the memory layout. That way we are able
  54. * to detect endianness when reading the perf.data file
  55. * back.
  56. *
  57. * we check for legacy (PERFFILE) format.
  58. */
  59. static const char *__perf_magic1 = "PERFFILE";
  60. static const u64 __perf_magic2 = 0x32454c4946524550ULL;
  61. static const u64 __perf_magic2_sw = 0x50455246494c4532ULL;
  62. #define PERF_MAGIC __perf_magic2
  63. struct perf_file_attr {
  64. struct perf_event_attr attr;
  65. struct perf_file_section ids;
  66. };
  67. void perf_header__set_feat(struct perf_header *header, int feat)
  68. {
  69. set_bit(feat, header->adds_features);
  70. }
  71. void perf_header__clear_feat(struct perf_header *header, int feat)
  72. {
  73. clear_bit(feat, header->adds_features);
  74. }
  75. bool perf_header__has_feat(const struct perf_header *header, int feat)
  76. {
  77. return test_bit(feat, header->adds_features);
  78. }
  79. static int do_write(int fd, const void *buf, size_t size)
  80. {
  81. while (size) {
  82. int ret = write(fd, buf, size);
  83. if (ret < 0)
  84. return -errno;
  85. size -= ret;
  86. buf += ret;
  87. }
  88. return 0;
  89. }
  90. #define NAME_ALIGN 64
  91. static int write_padded(int fd, const void *bf, size_t count,
  92. size_t count_aligned)
  93. {
  94. static const char zero_buf[NAME_ALIGN];
  95. int err = do_write(fd, bf, count);
  96. if (!err)
  97. err = do_write(fd, zero_buf, count_aligned - count);
  98. return err;
  99. }
  100. static int do_write_string(int fd, const char *str)
  101. {
  102. u32 len, olen;
  103. int ret;
  104. olen = strlen(str) + 1;
  105. len = ALIGN(olen, NAME_ALIGN);
  106. /* write len, incl. \0 */
  107. ret = do_write(fd, &len, sizeof(len));
  108. if (ret < 0)
  109. return ret;
  110. return write_padded(fd, str, olen, len);
  111. }
  112. static char *do_read_string(int fd, struct perf_header *ph)
  113. {
  114. ssize_t sz, ret;
  115. u32 len;
  116. char *buf;
  117. sz = read(fd, &len, sizeof(len));
  118. if (sz < (ssize_t)sizeof(len))
  119. return NULL;
  120. if (ph->needs_swap)
  121. len = bswap_32(len);
  122. buf = malloc(len);
  123. if (!buf)
  124. return NULL;
  125. ret = read(fd, buf, len);
  126. if (ret == (ssize_t)len) {
  127. /*
  128. * strings are padded by zeroes
  129. * thus the actual strlen of buf
  130. * may be less than len
  131. */
  132. return buf;
  133. }
  134. free(buf);
  135. return NULL;
  136. }
  137. int
  138. perf_header__set_cmdline(int argc, const char **argv)
  139. {
  140. int i;
  141. header_argc = (u32)argc;
  142. /* do not include NULL termination */
  143. header_argv = calloc(argc, sizeof(char *));
  144. if (!header_argv)
  145. return -ENOMEM;
  146. /*
  147. * must copy argv contents because it gets moved
  148. * around during option parsing
  149. */
  150. for (i = 0; i < argc ; i++)
  151. header_argv[i] = argv[i];
  152. return 0;
  153. }
  154. #define dsos__for_each_with_build_id(pos, head) \
  155. list_for_each_entry(pos, head, node) \
  156. if (!pos->has_build_id) \
  157. continue; \
  158. else
  159. static int __dsos__write_buildid_table(struct list_head *head, pid_t pid,
  160. u16 misc, int fd)
  161. {
  162. struct dso *pos;
  163. dsos__for_each_with_build_id(pos, head) {
  164. int err;
  165. struct build_id_event b;
  166. size_t len;
  167. if (!pos->hit)
  168. continue;
  169. len = pos->long_name_len + 1;
  170. len = ALIGN(len, NAME_ALIGN);
  171. memset(&b, 0, sizeof(b));
  172. memcpy(&b.build_id, pos->build_id, sizeof(pos->build_id));
  173. b.pid = pid;
  174. b.header.misc = misc;
  175. b.header.size = sizeof(b) + len;
  176. err = do_write(fd, &b, sizeof(b));
  177. if (err < 0)
  178. return err;
  179. err = write_padded(fd, pos->long_name,
  180. pos->long_name_len + 1, len);
  181. if (err < 0)
  182. return err;
  183. }
  184. return 0;
  185. }
  186. static int machine__write_buildid_table(struct machine *machine, int fd)
  187. {
  188. int err;
  189. u16 kmisc = PERF_RECORD_MISC_KERNEL,
  190. umisc = PERF_RECORD_MISC_USER;
  191. if (!machine__is_host(machine)) {
  192. kmisc = PERF_RECORD_MISC_GUEST_KERNEL;
  193. umisc = PERF_RECORD_MISC_GUEST_USER;
  194. }
  195. err = __dsos__write_buildid_table(&machine->kernel_dsos, machine->pid,
  196. kmisc, fd);
  197. if (err == 0)
  198. err = __dsos__write_buildid_table(&machine->user_dsos,
  199. machine->pid, umisc, fd);
  200. return err;
  201. }
  202. static int dsos__write_buildid_table(struct perf_header *header, int fd)
  203. {
  204. struct perf_session *session = container_of(header,
  205. struct perf_session, header);
  206. struct rb_node *nd;
  207. int err = machine__write_buildid_table(&session->host_machine, fd);
  208. if (err)
  209. return err;
  210. for (nd = rb_first(&session->machines); nd; nd = rb_next(nd)) {
  211. struct machine *pos = rb_entry(nd, struct machine, rb_node);
  212. err = machine__write_buildid_table(pos, fd);
  213. if (err)
  214. break;
  215. }
  216. return err;
  217. }
  218. int build_id_cache__add_s(const char *sbuild_id, const char *debugdir,
  219. const char *name, bool is_kallsyms)
  220. {
  221. const size_t size = PATH_MAX;
  222. char *realname, *filename = zalloc(size),
  223. *linkname = zalloc(size), *targetname;
  224. int len, err = -1;
  225. if (is_kallsyms) {
  226. if (symbol_conf.kptr_restrict) {
  227. pr_debug("Not caching a kptr_restrict'ed /proc/kallsyms\n");
  228. return 0;
  229. }
  230. realname = (char *)name;
  231. } else
  232. realname = realpath(name, NULL);
  233. if (realname == NULL || filename == NULL || linkname == NULL)
  234. goto out_free;
  235. len = scnprintf(filename, size, "%s%s%s",
  236. debugdir, is_kallsyms ? "/" : "", realname);
  237. if (mkdir_p(filename, 0755))
  238. goto out_free;
  239. snprintf(filename + len, size - len, "/%s", sbuild_id);
  240. if (access(filename, F_OK)) {
  241. if (is_kallsyms) {
  242. if (copyfile("/proc/kallsyms", filename))
  243. goto out_free;
  244. } else if (link(realname, filename) && copyfile(name, filename))
  245. goto out_free;
  246. }
  247. len = scnprintf(linkname, size, "%s/.build-id/%.2s",
  248. debugdir, sbuild_id);
  249. if (access(linkname, X_OK) && mkdir_p(linkname, 0755))
  250. goto out_free;
  251. snprintf(linkname + len, size - len, "/%s", sbuild_id + 2);
  252. targetname = filename + strlen(debugdir) - 5;
  253. memcpy(targetname, "../..", 5);
  254. if (symlink(targetname, linkname) == 0)
  255. err = 0;
  256. out_free:
  257. if (!is_kallsyms)
  258. free(realname);
  259. free(filename);
  260. free(linkname);
  261. return err;
  262. }
  263. static int build_id_cache__add_b(const u8 *build_id, size_t build_id_size,
  264. const char *name, const char *debugdir,
  265. bool is_kallsyms)
  266. {
  267. char sbuild_id[BUILD_ID_SIZE * 2 + 1];
  268. build_id__sprintf(build_id, build_id_size, sbuild_id);
  269. return build_id_cache__add_s(sbuild_id, debugdir, name, is_kallsyms);
  270. }
  271. int build_id_cache__remove_s(const char *sbuild_id, const char *debugdir)
  272. {
  273. const size_t size = PATH_MAX;
  274. char *filename = zalloc(size),
  275. *linkname = zalloc(size);
  276. int err = -1;
  277. if (filename == NULL || linkname == NULL)
  278. goto out_free;
  279. snprintf(linkname, size, "%s/.build-id/%.2s/%s",
  280. debugdir, sbuild_id, sbuild_id + 2);
  281. if (access(linkname, F_OK))
  282. goto out_free;
  283. if (readlink(linkname, filename, size - 1) < 0)
  284. goto out_free;
  285. if (unlink(linkname))
  286. goto out_free;
  287. /*
  288. * Since the link is relative, we must make it absolute:
  289. */
  290. snprintf(linkname, size, "%s/.build-id/%.2s/%s",
  291. debugdir, sbuild_id, filename);
  292. if (unlink(linkname))
  293. goto out_free;
  294. err = 0;
  295. out_free:
  296. free(filename);
  297. free(linkname);
  298. return err;
  299. }
  300. static int dso__cache_build_id(struct dso *dso, const char *debugdir)
  301. {
  302. bool is_kallsyms = dso->kernel && dso->long_name[0] != '/';
  303. return build_id_cache__add_b(dso->build_id, sizeof(dso->build_id),
  304. dso->long_name, debugdir, is_kallsyms);
  305. }
  306. static int __dsos__cache_build_ids(struct list_head *head, const char *debugdir)
  307. {
  308. struct dso *pos;
  309. int err = 0;
  310. dsos__for_each_with_build_id(pos, head)
  311. if (dso__cache_build_id(pos, debugdir))
  312. err = -1;
  313. return err;
  314. }
  315. static int machine__cache_build_ids(struct machine *machine, const char *debugdir)
  316. {
  317. int ret = __dsos__cache_build_ids(&machine->kernel_dsos, debugdir);
  318. ret |= __dsos__cache_build_ids(&machine->user_dsos, debugdir);
  319. return ret;
  320. }
  321. static int perf_session__cache_build_ids(struct perf_session *session)
  322. {
  323. struct rb_node *nd;
  324. int ret;
  325. char debugdir[PATH_MAX];
  326. snprintf(debugdir, sizeof(debugdir), "%s", buildid_dir);
  327. if (mkdir(debugdir, 0755) != 0 && errno != EEXIST)
  328. return -1;
  329. ret = machine__cache_build_ids(&session->host_machine, debugdir);
  330. for (nd = rb_first(&session->machines); nd; nd = rb_next(nd)) {
  331. struct machine *pos = rb_entry(nd, struct machine, rb_node);
  332. ret |= machine__cache_build_ids(pos, debugdir);
  333. }
  334. return ret ? -1 : 0;
  335. }
  336. static bool machine__read_build_ids(struct machine *machine, bool with_hits)
  337. {
  338. bool ret = __dsos__read_build_ids(&machine->kernel_dsos, with_hits);
  339. ret |= __dsos__read_build_ids(&machine->user_dsos, with_hits);
  340. return ret;
  341. }
  342. static bool perf_session__read_build_ids(struct perf_session *session, bool with_hits)
  343. {
  344. struct rb_node *nd;
  345. bool ret = machine__read_build_ids(&session->host_machine, with_hits);
  346. for (nd = rb_first(&session->machines); nd; nd = rb_next(nd)) {
  347. struct machine *pos = rb_entry(nd, struct machine, rb_node);
  348. ret |= machine__read_build_ids(pos, with_hits);
  349. }
  350. return ret;
  351. }
  352. static int write_tracing_data(int fd, struct perf_header *h __used,
  353. struct perf_evlist *evlist)
  354. {
  355. return read_tracing_data(fd, &evlist->entries);
  356. }
  357. static int write_build_id(int fd, struct perf_header *h,
  358. struct perf_evlist *evlist __used)
  359. {
  360. struct perf_session *session;
  361. int err;
  362. session = container_of(h, struct perf_session, header);
  363. if (!perf_session__read_build_ids(session, true))
  364. return -1;
  365. err = dsos__write_buildid_table(h, fd);
  366. if (err < 0) {
  367. pr_debug("failed to write buildid table\n");
  368. return err;
  369. }
  370. if (!no_buildid_cache)
  371. perf_session__cache_build_ids(session);
  372. return 0;
  373. }
  374. static int write_hostname(int fd, struct perf_header *h __used,
  375. struct perf_evlist *evlist __used)
  376. {
  377. struct utsname uts;
  378. int ret;
  379. ret = uname(&uts);
  380. if (ret < 0)
  381. return -1;
  382. return do_write_string(fd, uts.nodename);
  383. }
  384. static int write_osrelease(int fd, struct perf_header *h __used,
  385. struct perf_evlist *evlist __used)
  386. {
  387. struct utsname uts;
  388. int ret;
  389. ret = uname(&uts);
  390. if (ret < 0)
  391. return -1;
  392. return do_write_string(fd, uts.release);
  393. }
  394. static int write_arch(int fd, struct perf_header *h __used,
  395. struct perf_evlist *evlist __used)
  396. {
  397. struct utsname uts;
  398. int ret;
  399. ret = uname(&uts);
  400. if (ret < 0)
  401. return -1;
  402. return do_write_string(fd, uts.machine);
  403. }
  404. static int write_version(int fd, struct perf_header *h __used,
  405. struct perf_evlist *evlist __used)
  406. {
  407. return do_write_string(fd, perf_version_string);
  408. }
  409. static int write_cpudesc(int fd, struct perf_header *h __used,
  410. struct perf_evlist *evlist __used)
  411. {
  412. #ifndef CPUINFO_PROC
  413. #define CPUINFO_PROC NULL
  414. #endif
  415. FILE *file;
  416. char *buf = NULL;
  417. char *s, *p;
  418. const char *search = CPUINFO_PROC;
  419. size_t len = 0;
  420. int ret = -1;
  421. if (!search)
  422. return -1;
  423. file = fopen("/proc/cpuinfo", "r");
  424. if (!file)
  425. return -1;
  426. while (getline(&buf, &len, file) > 0) {
  427. ret = strncmp(buf, search, strlen(search));
  428. if (!ret)
  429. break;
  430. }
  431. if (ret)
  432. goto done;
  433. s = buf;
  434. p = strchr(buf, ':');
  435. if (p && *(p+1) == ' ' && *(p+2))
  436. s = p + 2;
  437. p = strchr(s, '\n');
  438. if (p)
  439. *p = '\0';
  440. /* squash extra space characters (branding string) */
  441. p = s;
  442. while (*p) {
  443. if (isspace(*p)) {
  444. char *r = p + 1;
  445. char *q = r;
  446. *p = ' ';
  447. while (*q && isspace(*q))
  448. q++;
  449. if (q != (p+1))
  450. while ((*r++ = *q++));
  451. }
  452. p++;
  453. }
  454. ret = do_write_string(fd, s);
  455. done:
  456. free(buf);
  457. fclose(file);
  458. return ret;
  459. }
  460. static int write_nrcpus(int fd, struct perf_header *h __used,
  461. struct perf_evlist *evlist __used)
  462. {
  463. long nr;
  464. u32 nrc, nra;
  465. int ret;
  466. nr = sysconf(_SC_NPROCESSORS_CONF);
  467. if (nr < 0)
  468. return -1;
  469. nrc = (u32)(nr & UINT_MAX);
  470. nr = sysconf(_SC_NPROCESSORS_ONLN);
  471. if (nr < 0)
  472. return -1;
  473. nra = (u32)(nr & UINT_MAX);
  474. ret = do_write(fd, &nrc, sizeof(nrc));
  475. if (ret < 0)
  476. return ret;
  477. return do_write(fd, &nra, sizeof(nra));
  478. }
  479. static int write_event_desc(int fd, struct perf_header *h __used,
  480. struct perf_evlist *evlist)
  481. {
  482. struct perf_evsel *attr;
  483. u32 nre = 0, nri, sz;
  484. int ret;
  485. list_for_each_entry(attr, &evlist->entries, node)
  486. nre++;
  487. /*
  488. * write number of events
  489. */
  490. ret = do_write(fd, &nre, sizeof(nre));
  491. if (ret < 0)
  492. return ret;
  493. /*
  494. * size of perf_event_attr struct
  495. */
  496. sz = (u32)sizeof(attr->attr);
  497. ret = do_write(fd, &sz, sizeof(sz));
  498. if (ret < 0)
  499. return ret;
  500. list_for_each_entry(attr, &evlist->entries, node) {
  501. ret = do_write(fd, &attr->attr, sz);
  502. if (ret < 0)
  503. return ret;
  504. /*
  505. * write number of unique id per event
  506. * there is one id per instance of an event
  507. *
  508. * copy into an nri to be independent of the
  509. * type of ids,
  510. */
  511. nri = attr->ids;
  512. ret = do_write(fd, &nri, sizeof(nri));
  513. if (ret < 0)
  514. return ret;
  515. /*
  516. * write event string as passed on cmdline
  517. */
  518. ret = do_write_string(fd, event_name(attr));
  519. if (ret < 0)
  520. return ret;
  521. /*
  522. * write unique ids for this event
  523. */
  524. ret = do_write(fd, attr->id, attr->ids * sizeof(u64));
  525. if (ret < 0)
  526. return ret;
  527. }
  528. return 0;
  529. }
  530. static int write_cmdline(int fd, struct perf_header *h __used,
  531. struct perf_evlist *evlist __used)
  532. {
  533. char buf[MAXPATHLEN];
  534. char proc[32];
  535. u32 i, n;
  536. int ret;
  537. /*
  538. * actual atual path to perf binary
  539. */
  540. sprintf(proc, "/proc/%d/exe", getpid());
  541. ret = readlink(proc, buf, sizeof(buf));
  542. if (ret <= 0)
  543. return -1;
  544. /* readlink() does not add null termination */
  545. buf[ret] = '\0';
  546. /* account for binary path */
  547. n = header_argc + 1;
  548. ret = do_write(fd, &n, sizeof(n));
  549. if (ret < 0)
  550. return ret;
  551. ret = do_write_string(fd, buf);
  552. if (ret < 0)
  553. return ret;
  554. for (i = 0 ; i < header_argc; i++) {
  555. ret = do_write_string(fd, header_argv[i]);
  556. if (ret < 0)
  557. return ret;
  558. }
  559. return 0;
  560. }
  561. #define CORE_SIB_FMT \
  562. "/sys/devices/system/cpu/cpu%d/topology/core_siblings_list"
  563. #define THRD_SIB_FMT \
  564. "/sys/devices/system/cpu/cpu%d/topology/thread_siblings_list"
  565. struct cpu_topo {
  566. u32 core_sib;
  567. u32 thread_sib;
  568. char **core_siblings;
  569. char **thread_siblings;
  570. };
  571. static int build_cpu_topo(struct cpu_topo *tp, int cpu)
  572. {
  573. FILE *fp;
  574. char filename[MAXPATHLEN];
  575. char *buf = NULL, *p;
  576. size_t len = 0;
  577. u32 i = 0;
  578. int ret = -1;
  579. sprintf(filename, CORE_SIB_FMT, cpu);
  580. fp = fopen(filename, "r");
  581. if (!fp)
  582. return -1;
  583. if (getline(&buf, &len, fp) <= 0)
  584. goto done;
  585. fclose(fp);
  586. p = strchr(buf, '\n');
  587. if (p)
  588. *p = '\0';
  589. for (i = 0; i < tp->core_sib; i++) {
  590. if (!strcmp(buf, tp->core_siblings[i]))
  591. break;
  592. }
  593. if (i == tp->core_sib) {
  594. tp->core_siblings[i] = buf;
  595. tp->core_sib++;
  596. buf = NULL;
  597. len = 0;
  598. }
  599. sprintf(filename, THRD_SIB_FMT, cpu);
  600. fp = fopen(filename, "r");
  601. if (!fp)
  602. goto done;
  603. if (getline(&buf, &len, fp) <= 0)
  604. goto done;
  605. p = strchr(buf, '\n');
  606. if (p)
  607. *p = '\0';
  608. for (i = 0; i < tp->thread_sib; i++) {
  609. if (!strcmp(buf, tp->thread_siblings[i]))
  610. break;
  611. }
  612. if (i == tp->thread_sib) {
  613. tp->thread_siblings[i] = buf;
  614. tp->thread_sib++;
  615. buf = NULL;
  616. }
  617. ret = 0;
  618. done:
  619. if(fp)
  620. fclose(fp);
  621. free(buf);
  622. return ret;
  623. }
  624. static void free_cpu_topo(struct cpu_topo *tp)
  625. {
  626. u32 i;
  627. if (!tp)
  628. return;
  629. for (i = 0 ; i < tp->core_sib; i++)
  630. free(tp->core_siblings[i]);
  631. for (i = 0 ; i < tp->thread_sib; i++)
  632. free(tp->thread_siblings[i]);
  633. free(tp);
  634. }
  635. static struct cpu_topo *build_cpu_topology(void)
  636. {
  637. struct cpu_topo *tp;
  638. void *addr;
  639. u32 nr, i;
  640. size_t sz;
  641. long ncpus;
  642. int ret = -1;
  643. ncpus = sysconf(_SC_NPROCESSORS_CONF);
  644. if (ncpus < 0)
  645. return NULL;
  646. nr = (u32)(ncpus & UINT_MAX);
  647. sz = nr * sizeof(char *);
  648. addr = calloc(1, sizeof(*tp) + 2 * sz);
  649. if (!addr)
  650. return NULL;
  651. tp = addr;
  652. addr += sizeof(*tp);
  653. tp->core_siblings = addr;
  654. addr += sz;
  655. tp->thread_siblings = addr;
  656. for (i = 0; i < nr; i++) {
  657. ret = build_cpu_topo(tp, i);
  658. if (ret < 0)
  659. break;
  660. }
  661. if (ret) {
  662. free_cpu_topo(tp);
  663. tp = NULL;
  664. }
  665. return tp;
  666. }
  667. static int write_cpu_topology(int fd, struct perf_header *h __used,
  668. struct perf_evlist *evlist __used)
  669. {
  670. struct cpu_topo *tp;
  671. u32 i;
  672. int ret;
  673. tp = build_cpu_topology();
  674. if (!tp)
  675. return -1;
  676. ret = do_write(fd, &tp->core_sib, sizeof(tp->core_sib));
  677. if (ret < 0)
  678. goto done;
  679. for (i = 0; i < tp->core_sib; i++) {
  680. ret = do_write_string(fd, tp->core_siblings[i]);
  681. if (ret < 0)
  682. goto done;
  683. }
  684. ret = do_write(fd, &tp->thread_sib, sizeof(tp->thread_sib));
  685. if (ret < 0)
  686. goto done;
  687. for (i = 0; i < tp->thread_sib; i++) {
  688. ret = do_write_string(fd, tp->thread_siblings[i]);
  689. if (ret < 0)
  690. break;
  691. }
  692. done:
  693. free_cpu_topo(tp);
  694. return ret;
  695. }
  696. static int write_total_mem(int fd, struct perf_header *h __used,
  697. struct perf_evlist *evlist __used)
  698. {
  699. char *buf = NULL;
  700. FILE *fp;
  701. size_t len = 0;
  702. int ret = -1, n;
  703. uint64_t mem;
  704. fp = fopen("/proc/meminfo", "r");
  705. if (!fp)
  706. return -1;
  707. while (getline(&buf, &len, fp) > 0) {
  708. ret = strncmp(buf, "MemTotal:", 9);
  709. if (!ret)
  710. break;
  711. }
  712. if (!ret) {
  713. n = sscanf(buf, "%*s %"PRIu64, &mem);
  714. if (n == 1)
  715. ret = do_write(fd, &mem, sizeof(mem));
  716. }
  717. free(buf);
  718. fclose(fp);
  719. return ret;
  720. }
  721. static int write_topo_node(int fd, int node)
  722. {
  723. char str[MAXPATHLEN];
  724. char field[32];
  725. char *buf = NULL, *p;
  726. size_t len = 0;
  727. FILE *fp;
  728. u64 mem_total, mem_free, mem;
  729. int ret = -1;
  730. sprintf(str, "/sys/devices/system/node/node%d/meminfo", node);
  731. fp = fopen(str, "r");
  732. if (!fp)
  733. return -1;
  734. while (getline(&buf, &len, fp) > 0) {
  735. /* skip over invalid lines */
  736. if (!strchr(buf, ':'))
  737. continue;
  738. if (sscanf(buf, "%*s %*d %s %"PRIu64, field, &mem) != 2)
  739. goto done;
  740. if (!strcmp(field, "MemTotal:"))
  741. mem_total = mem;
  742. if (!strcmp(field, "MemFree:"))
  743. mem_free = mem;
  744. }
  745. fclose(fp);
  746. ret = do_write(fd, &mem_total, sizeof(u64));
  747. if (ret)
  748. goto done;
  749. ret = do_write(fd, &mem_free, sizeof(u64));
  750. if (ret)
  751. goto done;
  752. ret = -1;
  753. sprintf(str, "/sys/devices/system/node/node%d/cpulist", node);
  754. fp = fopen(str, "r");
  755. if (!fp)
  756. goto done;
  757. if (getline(&buf, &len, fp) <= 0)
  758. goto done;
  759. p = strchr(buf, '\n');
  760. if (p)
  761. *p = '\0';
  762. ret = do_write_string(fd, buf);
  763. done:
  764. free(buf);
  765. fclose(fp);
  766. return ret;
  767. }
  768. static int write_numa_topology(int fd, struct perf_header *h __used,
  769. struct perf_evlist *evlist __used)
  770. {
  771. char *buf = NULL;
  772. size_t len = 0;
  773. FILE *fp;
  774. struct cpu_map *node_map = NULL;
  775. char *c;
  776. u32 nr, i, j;
  777. int ret = -1;
  778. fp = fopen("/sys/devices/system/node/online", "r");
  779. if (!fp)
  780. return -1;
  781. if (getline(&buf, &len, fp) <= 0)
  782. goto done;
  783. c = strchr(buf, '\n');
  784. if (c)
  785. *c = '\0';
  786. node_map = cpu_map__new(buf);
  787. if (!node_map)
  788. goto done;
  789. nr = (u32)node_map->nr;
  790. ret = do_write(fd, &nr, sizeof(nr));
  791. if (ret < 0)
  792. goto done;
  793. for (i = 0; i < nr; i++) {
  794. j = (u32)node_map->map[i];
  795. ret = do_write(fd, &j, sizeof(j));
  796. if (ret < 0)
  797. break;
  798. ret = write_topo_node(fd, i);
  799. if (ret < 0)
  800. break;
  801. }
  802. done:
  803. free(buf);
  804. fclose(fp);
  805. free(node_map);
  806. return ret;
  807. }
  808. /*
  809. * default get_cpuid(): nothing gets recorded
  810. * actual implementation must be in arch/$(ARCH)/util/header.c
  811. */
  812. int __attribute__((weak)) get_cpuid(char *buffer __used, size_t sz __used)
  813. {
  814. return -1;
  815. }
  816. static int write_cpuid(int fd, struct perf_header *h __used,
  817. struct perf_evlist *evlist __used)
  818. {
  819. char buffer[64];
  820. int ret;
  821. ret = get_cpuid(buffer, sizeof(buffer));
  822. if (!ret)
  823. goto write_it;
  824. return -1;
  825. write_it:
  826. return do_write_string(fd, buffer);
  827. }
  828. static int write_branch_stack(int fd __used, struct perf_header *h __used,
  829. struct perf_evlist *evlist __used)
  830. {
  831. return 0;
  832. }
  833. static void print_hostname(struct perf_header *ph, int fd, FILE *fp)
  834. {
  835. char *str = do_read_string(fd, ph);
  836. fprintf(fp, "# hostname : %s\n", str);
  837. free(str);
  838. }
  839. static void print_osrelease(struct perf_header *ph, int fd, FILE *fp)
  840. {
  841. char *str = do_read_string(fd, ph);
  842. fprintf(fp, "# os release : %s\n", str);
  843. free(str);
  844. }
  845. static void print_arch(struct perf_header *ph, int fd, FILE *fp)
  846. {
  847. char *str = do_read_string(fd, ph);
  848. fprintf(fp, "# arch : %s\n", str);
  849. free(str);
  850. }
  851. static void print_cpudesc(struct perf_header *ph, int fd, FILE *fp)
  852. {
  853. char *str = do_read_string(fd, ph);
  854. fprintf(fp, "# cpudesc : %s\n", str);
  855. free(str);
  856. }
  857. static void print_nrcpus(struct perf_header *ph, int fd, FILE *fp)
  858. {
  859. ssize_t ret;
  860. u32 nr;
  861. ret = read(fd, &nr, sizeof(nr));
  862. if (ret != (ssize_t)sizeof(nr))
  863. nr = -1; /* interpreted as error */
  864. if (ph->needs_swap)
  865. nr = bswap_32(nr);
  866. fprintf(fp, "# nrcpus online : %u\n", nr);
  867. ret = read(fd, &nr, sizeof(nr));
  868. if (ret != (ssize_t)sizeof(nr))
  869. nr = -1; /* interpreted as error */
  870. if (ph->needs_swap)
  871. nr = bswap_32(nr);
  872. fprintf(fp, "# nrcpus avail : %u\n", nr);
  873. }
  874. static void print_version(struct perf_header *ph, int fd, FILE *fp)
  875. {
  876. char *str = do_read_string(fd, ph);
  877. fprintf(fp, "# perf version : %s\n", str);
  878. free(str);
  879. }
  880. static void print_cmdline(struct perf_header *ph, int fd, FILE *fp)
  881. {
  882. ssize_t ret;
  883. char *str;
  884. u32 nr, i;
  885. ret = read(fd, &nr, sizeof(nr));
  886. if (ret != (ssize_t)sizeof(nr))
  887. return;
  888. if (ph->needs_swap)
  889. nr = bswap_32(nr);
  890. fprintf(fp, "# cmdline : ");
  891. for (i = 0; i < nr; i++) {
  892. str = do_read_string(fd, ph);
  893. fprintf(fp, "%s ", str);
  894. free(str);
  895. }
  896. fputc('\n', fp);
  897. }
  898. static void print_cpu_topology(struct perf_header *ph, int fd, FILE *fp)
  899. {
  900. ssize_t ret;
  901. u32 nr, i;
  902. char *str;
  903. ret = read(fd, &nr, sizeof(nr));
  904. if (ret != (ssize_t)sizeof(nr))
  905. return;
  906. if (ph->needs_swap)
  907. nr = bswap_32(nr);
  908. for (i = 0; i < nr; i++) {
  909. str = do_read_string(fd, ph);
  910. fprintf(fp, "# sibling cores : %s\n", str);
  911. free(str);
  912. }
  913. ret = read(fd, &nr, sizeof(nr));
  914. if (ret != (ssize_t)sizeof(nr))
  915. return;
  916. if (ph->needs_swap)
  917. nr = bswap_32(nr);
  918. for (i = 0; i < nr; i++) {
  919. str = do_read_string(fd, ph);
  920. fprintf(fp, "# sibling threads : %s\n", str);
  921. free(str);
  922. }
  923. }
  924. static void print_event_desc(struct perf_header *ph, int fd, FILE *fp)
  925. {
  926. struct perf_event_attr attr;
  927. uint64_t id;
  928. void *buf = NULL;
  929. char *str;
  930. u32 nre, sz, nr, i, j;
  931. ssize_t ret;
  932. size_t msz;
  933. /* number of events */
  934. ret = read(fd, &nre, sizeof(nre));
  935. if (ret != (ssize_t)sizeof(nre))
  936. goto error;
  937. if (ph->needs_swap)
  938. nre = bswap_32(nre);
  939. ret = read(fd, &sz, sizeof(sz));
  940. if (ret != (ssize_t)sizeof(sz))
  941. goto error;
  942. if (ph->needs_swap)
  943. sz = bswap_32(sz);
  944. memset(&attr, 0, sizeof(attr));
  945. /* buffer to hold on file attr struct */
  946. buf = malloc(sz);
  947. if (!buf)
  948. goto error;
  949. msz = sizeof(attr);
  950. if (sz < msz)
  951. msz = sz;
  952. for (i = 0 ; i < nre; i++) {
  953. /*
  954. * must read entire on-file attr struct to
  955. * sync up with layout.
  956. */
  957. ret = read(fd, buf, sz);
  958. if (ret != (ssize_t)sz)
  959. goto error;
  960. if (ph->needs_swap)
  961. perf_event__attr_swap(buf);
  962. memcpy(&attr, buf, msz);
  963. ret = read(fd, &nr, sizeof(nr));
  964. if (ret != (ssize_t)sizeof(nr))
  965. goto error;
  966. if (ph->needs_swap)
  967. nr = bswap_32(nr);
  968. str = do_read_string(fd, ph);
  969. fprintf(fp, "# event : name = %s, ", str);
  970. free(str);
  971. fprintf(fp, "type = %d, config = 0x%"PRIx64
  972. ", config1 = 0x%"PRIx64", config2 = 0x%"PRIx64,
  973. attr.type,
  974. (u64)attr.config,
  975. (u64)attr.config1,
  976. (u64)attr.config2);
  977. fprintf(fp, ", excl_usr = %d, excl_kern = %d",
  978. attr.exclude_user,
  979. attr.exclude_kernel);
  980. if (nr)
  981. fprintf(fp, ", id = {");
  982. for (j = 0 ; j < nr; j++) {
  983. ret = read(fd, &id, sizeof(id));
  984. if (ret != (ssize_t)sizeof(id))
  985. goto error;
  986. if (ph->needs_swap)
  987. id = bswap_64(id);
  988. if (j)
  989. fputc(',', fp);
  990. fprintf(fp, " %"PRIu64, id);
  991. }
  992. if (nr && j == nr)
  993. fprintf(fp, " }");
  994. fputc('\n', fp);
  995. }
  996. free(buf);
  997. return;
  998. error:
  999. fprintf(fp, "# event desc: not available or unable to read\n");
  1000. }
  1001. static void print_total_mem(struct perf_header *h __used, int fd, FILE *fp)
  1002. {
  1003. uint64_t mem;
  1004. ssize_t ret;
  1005. ret = read(fd, &mem, sizeof(mem));
  1006. if (ret != sizeof(mem))
  1007. goto error;
  1008. if (h->needs_swap)
  1009. mem = bswap_64(mem);
  1010. fprintf(fp, "# total memory : %"PRIu64" kB\n", mem);
  1011. return;
  1012. error:
  1013. fprintf(fp, "# total memory : unknown\n");
  1014. }
  1015. static void print_numa_topology(struct perf_header *h __used, int fd, FILE *fp)
  1016. {
  1017. ssize_t ret;
  1018. u32 nr, c, i;
  1019. char *str;
  1020. uint64_t mem_total, mem_free;
  1021. /* nr nodes */
  1022. ret = read(fd, &nr, sizeof(nr));
  1023. if (ret != (ssize_t)sizeof(nr))
  1024. goto error;
  1025. if (h->needs_swap)
  1026. nr = bswap_32(nr);
  1027. for (i = 0; i < nr; i++) {
  1028. /* node number */
  1029. ret = read(fd, &c, sizeof(c));
  1030. if (ret != (ssize_t)sizeof(c))
  1031. goto error;
  1032. if (h->needs_swap)
  1033. c = bswap_32(c);
  1034. ret = read(fd, &mem_total, sizeof(u64));
  1035. if (ret != sizeof(u64))
  1036. goto error;
  1037. ret = read(fd, &mem_free, sizeof(u64));
  1038. if (ret != sizeof(u64))
  1039. goto error;
  1040. if (h->needs_swap) {
  1041. mem_total = bswap_64(mem_total);
  1042. mem_free = bswap_64(mem_free);
  1043. }
  1044. fprintf(fp, "# node%u meminfo : total = %"PRIu64" kB,"
  1045. " free = %"PRIu64" kB\n",
  1046. c,
  1047. mem_total,
  1048. mem_free);
  1049. str = do_read_string(fd, h);
  1050. fprintf(fp, "# node%u cpu list : %s\n", c, str);
  1051. free(str);
  1052. }
  1053. return;
  1054. error:
  1055. fprintf(fp, "# numa topology : not available\n");
  1056. }
  1057. static void print_cpuid(struct perf_header *ph, int fd, FILE *fp)
  1058. {
  1059. char *str = do_read_string(fd, ph);
  1060. fprintf(fp, "# cpuid : %s\n", str);
  1061. free(str);
  1062. }
  1063. static void print_branch_stack(struct perf_header *ph __used, int fd __used,
  1064. FILE *fp)
  1065. {
  1066. fprintf(fp, "# contains samples with branch stack\n");
  1067. }
  1068. static int __event_process_build_id(struct build_id_event *bev,
  1069. char *filename,
  1070. struct perf_session *session)
  1071. {
  1072. int err = -1;
  1073. struct list_head *head;
  1074. struct machine *machine;
  1075. u16 misc;
  1076. struct dso *dso;
  1077. enum dso_kernel_type dso_type;
  1078. machine = perf_session__findnew_machine(session, bev->pid);
  1079. if (!machine)
  1080. goto out;
  1081. misc = bev->header.misc & PERF_RECORD_MISC_CPUMODE_MASK;
  1082. switch (misc) {
  1083. case PERF_RECORD_MISC_KERNEL:
  1084. dso_type = DSO_TYPE_KERNEL;
  1085. head = &machine->kernel_dsos;
  1086. break;
  1087. case PERF_RECORD_MISC_GUEST_KERNEL:
  1088. dso_type = DSO_TYPE_GUEST_KERNEL;
  1089. head = &machine->kernel_dsos;
  1090. break;
  1091. case PERF_RECORD_MISC_USER:
  1092. case PERF_RECORD_MISC_GUEST_USER:
  1093. dso_type = DSO_TYPE_USER;
  1094. head = &machine->user_dsos;
  1095. break;
  1096. default:
  1097. goto out;
  1098. }
  1099. dso = __dsos__findnew(head, filename);
  1100. if (dso != NULL) {
  1101. char sbuild_id[BUILD_ID_SIZE * 2 + 1];
  1102. dso__set_build_id(dso, &bev->build_id);
  1103. if (filename[0] == '[')
  1104. dso->kernel = dso_type;
  1105. build_id__sprintf(dso->build_id, sizeof(dso->build_id),
  1106. sbuild_id);
  1107. pr_debug("build id event received for %s: %s\n",
  1108. dso->long_name, sbuild_id);
  1109. }
  1110. err = 0;
  1111. out:
  1112. return err;
  1113. }
  1114. static int perf_header__read_build_ids_abi_quirk(struct perf_header *header,
  1115. int input, u64 offset, u64 size)
  1116. {
  1117. struct perf_session *session = container_of(header, struct perf_session, header);
  1118. struct {
  1119. struct perf_event_header header;
  1120. u8 build_id[ALIGN(BUILD_ID_SIZE, sizeof(u64))];
  1121. char filename[0];
  1122. } old_bev;
  1123. struct build_id_event bev;
  1124. char filename[PATH_MAX];
  1125. u64 limit = offset + size;
  1126. while (offset < limit) {
  1127. ssize_t len;
  1128. if (read(input, &old_bev, sizeof(old_bev)) != sizeof(old_bev))
  1129. return -1;
  1130. if (header->needs_swap)
  1131. perf_event_header__bswap(&old_bev.header);
  1132. len = old_bev.header.size - sizeof(old_bev);
  1133. if (read(input, filename, len) != len)
  1134. return -1;
  1135. bev.header = old_bev.header;
  1136. /*
  1137. * As the pid is the missing value, we need to fill
  1138. * it properly. The header.misc value give us nice hint.
  1139. */
  1140. bev.pid = HOST_KERNEL_ID;
  1141. if (bev.header.misc == PERF_RECORD_MISC_GUEST_USER ||
  1142. bev.header.misc == PERF_RECORD_MISC_GUEST_KERNEL)
  1143. bev.pid = DEFAULT_GUEST_KERNEL_ID;
  1144. memcpy(bev.build_id, old_bev.build_id, sizeof(bev.build_id));
  1145. __event_process_build_id(&bev, filename, session);
  1146. offset += bev.header.size;
  1147. }
  1148. return 0;
  1149. }
  1150. static int perf_header__read_build_ids(struct perf_header *header,
  1151. int input, u64 offset, u64 size)
  1152. {
  1153. struct perf_session *session = container_of(header, struct perf_session, header);
  1154. struct build_id_event bev;
  1155. char filename[PATH_MAX];
  1156. u64 limit = offset + size, orig_offset = offset;
  1157. int err = -1;
  1158. while (offset < limit) {
  1159. ssize_t len;
  1160. if (read(input, &bev, sizeof(bev)) != sizeof(bev))
  1161. goto out;
  1162. if (header->needs_swap)
  1163. perf_event_header__bswap(&bev.header);
  1164. len = bev.header.size - sizeof(bev);
  1165. if (read(input, filename, len) != len)
  1166. goto out;
  1167. /*
  1168. * The a1645ce1 changeset:
  1169. *
  1170. * "perf: 'perf kvm' tool for monitoring guest performance from host"
  1171. *
  1172. * Added a field to struct build_id_event that broke the file
  1173. * format.
  1174. *
  1175. * Since the kernel build-id is the first entry, process the
  1176. * table using the old format if the well known
  1177. * '[kernel.kallsyms]' string for the kernel build-id has the
  1178. * first 4 characters chopped off (where the pid_t sits).
  1179. */
  1180. if (memcmp(filename, "nel.kallsyms]", 13) == 0) {
  1181. if (lseek(input, orig_offset, SEEK_SET) == (off_t)-1)
  1182. return -1;
  1183. return perf_header__read_build_ids_abi_quirk(header, input, offset, size);
  1184. }
  1185. __event_process_build_id(&bev, filename, session);
  1186. offset += bev.header.size;
  1187. }
  1188. err = 0;
  1189. out:
  1190. return err;
  1191. }
  1192. static int process_tracing_data(struct perf_file_section *section __unused,
  1193. struct perf_header *ph __unused,
  1194. int feat __unused, int fd)
  1195. {
  1196. trace_report(fd, false);
  1197. return 0;
  1198. }
  1199. static int process_build_id(struct perf_file_section *section,
  1200. struct perf_header *ph,
  1201. int feat __unused, int fd)
  1202. {
  1203. if (perf_header__read_build_ids(ph, fd, section->offset, section->size))
  1204. pr_debug("Failed to read buildids, continuing...\n");
  1205. return 0;
  1206. }
  1207. struct feature_ops {
  1208. int (*write)(int fd, struct perf_header *h, struct perf_evlist *evlist);
  1209. void (*print)(struct perf_header *h, int fd, FILE *fp);
  1210. int (*process)(struct perf_file_section *section,
  1211. struct perf_header *h, int feat, int fd);
  1212. const char *name;
  1213. bool full_only;
  1214. };
  1215. #define FEAT_OPA(n, func) \
  1216. [n] = { .name = #n, .write = write_##func, .print = print_##func }
  1217. #define FEAT_OPP(n, func) \
  1218. [n] = { .name = #n, .write = write_##func, .print = print_##func, \
  1219. .process = process_##func }
  1220. #define FEAT_OPF(n, func) \
  1221. [n] = { .name = #n, .write = write_##func, .print = print_##func, \
  1222. .full_only = true }
  1223. /* feature_ops not implemented: */
  1224. #define print_tracing_data NULL
  1225. #define print_build_id NULL
  1226. static const struct feature_ops feat_ops[HEADER_LAST_FEATURE] = {
  1227. FEAT_OPP(HEADER_TRACING_DATA, tracing_data),
  1228. FEAT_OPP(HEADER_BUILD_ID, build_id),
  1229. FEAT_OPA(HEADER_HOSTNAME, hostname),
  1230. FEAT_OPA(HEADER_OSRELEASE, osrelease),
  1231. FEAT_OPA(HEADER_VERSION, version),
  1232. FEAT_OPA(HEADER_ARCH, arch),
  1233. FEAT_OPA(HEADER_NRCPUS, nrcpus),
  1234. FEAT_OPA(HEADER_CPUDESC, cpudesc),
  1235. FEAT_OPA(HEADER_CPUID, cpuid),
  1236. FEAT_OPA(HEADER_TOTAL_MEM, total_mem),
  1237. FEAT_OPA(HEADER_EVENT_DESC, event_desc),
  1238. FEAT_OPA(HEADER_CMDLINE, cmdline),
  1239. FEAT_OPF(HEADER_CPU_TOPOLOGY, cpu_topology),
  1240. FEAT_OPF(HEADER_NUMA_TOPOLOGY, numa_topology),
  1241. FEAT_OPA(HEADER_BRANCH_STACK, branch_stack),
  1242. };
  1243. struct header_print_data {
  1244. FILE *fp;
  1245. bool full; /* extended list of headers */
  1246. };
  1247. static int perf_file_section__fprintf_info(struct perf_file_section *section,
  1248. struct perf_header *ph,
  1249. int feat, int fd, void *data)
  1250. {
  1251. struct header_print_data *hd = data;
  1252. if (lseek(fd, section->offset, SEEK_SET) == (off_t)-1) {
  1253. pr_debug("Failed to lseek to %" PRIu64 " offset for feature "
  1254. "%d, continuing...\n", section->offset, feat);
  1255. return 0;
  1256. }
  1257. if (feat >= HEADER_LAST_FEATURE) {
  1258. pr_warning("unknown feature %d\n", feat);
  1259. return 0;
  1260. }
  1261. if (!feat_ops[feat].print)
  1262. return 0;
  1263. if (!feat_ops[feat].full_only || hd->full)
  1264. feat_ops[feat].print(ph, fd, hd->fp);
  1265. else
  1266. fprintf(hd->fp, "# %s info available, use -I to display\n",
  1267. feat_ops[feat].name);
  1268. return 0;
  1269. }
  1270. int perf_header__fprintf_info(struct perf_session *session, FILE *fp, bool full)
  1271. {
  1272. struct header_print_data hd;
  1273. struct perf_header *header = &session->header;
  1274. int fd = session->fd;
  1275. hd.fp = fp;
  1276. hd.full = full;
  1277. perf_header__process_sections(header, fd, &hd,
  1278. perf_file_section__fprintf_info);
  1279. return 0;
  1280. }
  1281. static int do_write_feat(int fd, struct perf_header *h, int type,
  1282. struct perf_file_section **p,
  1283. struct perf_evlist *evlist)
  1284. {
  1285. int err;
  1286. int ret = 0;
  1287. if (perf_header__has_feat(h, type)) {
  1288. if (!feat_ops[type].write)
  1289. return -1;
  1290. (*p)->offset = lseek(fd, 0, SEEK_CUR);
  1291. err = feat_ops[type].write(fd, h, evlist);
  1292. if (err < 0) {
  1293. pr_debug("failed to write feature %d\n", type);
  1294. /* undo anything written */
  1295. lseek(fd, (*p)->offset, SEEK_SET);
  1296. return -1;
  1297. }
  1298. (*p)->size = lseek(fd, 0, SEEK_CUR) - (*p)->offset;
  1299. (*p)++;
  1300. }
  1301. return ret;
  1302. }
  1303. static int perf_header__adds_write(struct perf_header *header,
  1304. struct perf_evlist *evlist, int fd)
  1305. {
  1306. int nr_sections;
  1307. struct perf_file_section *feat_sec, *p;
  1308. int sec_size;
  1309. u64 sec_start;
  1310. int feat;
  1311. int err;
  1312. nr_sections = bitmap_weight(header->adds_features, HEADER_FEAT_BITS);
  1313. if (!nr_sections)
  1314. return 0;
  1315. feat_sec = p = calloc(sizeof(*feat_sec), nr_sections);
  1316. if (feat_sec == NULL)
  1317. return -ENOMEM;
  1318. sec_size = sizeof(*feat_sec) * nr_sections;
  1319. sec_start = header->data_offset + header->data_size;
  1320. lseek(fd, sec_start + sec_size, SEEK_SET);
  1321. for_each_set_bit(feat, header->adds_features, HEADER_FEAT_BITS) {
  1322. if (do_write_feat(fd, header, feat, &p, evlist))
  1323. perf_header__clear_feat(header, feat);
  1324. }
  1325. lseek(fd, sec_start, SEEK_SET);
  1326. /*
  1327. * may write more than needed due to dropped feature, but
  1328. * this is okay, reader will skip the mising entries
  1329. */
  1330. err = do_write(fd, feat_sec, sec_size);
  1331. if (err < 0)
  1332. pr_debug("failed to write feature section\n");
  1333. free(feat_sec);
  1334. return err;
  1335. }
  1336. int perf_header__write_pipe(int fd)
  1337. {
  1338. struct perf_pipe_file_header f_header;
  1339. int err;
  1340. f_header = (struct perf_pipe_file_header){
  1341. .magic = PERF_MAGIC,
  1342. .size = sizeof(f_header),
  1343. };
  1344. err = do_write(fd, &f_header, sizeof(f_header));
  1345. if (err < 0) {
  1346. pr_debug("failed to write perf pipe header\n");
  1347. return err;
  1348. }
  1349. return 0;
  1350. }
  1351. int perf_session__write_header(struct perf_session *session,
  1352. struct perf_evlist *evlist,
  1353. int fd, bool at_exit)
  1354. {
  1355. struct perf_file_header f_header;
  1356. struct perf_file_attr f_attr;
  1357. struct perf_header *header = &session->header;
  1358. struct perf_evsel *attr, *pair = NULL;
  1359. int err;
  1360. lseek(fd, sizeof(f_header), SEEK_SET);
  1361. if (session->evlist != evlist)
  1362. pair = list_entry(session->evlist->entries.next, struct perf_evsel, node);
  1363. list_for_each_entry(attr, &evlist->entries, node) {
  1364. attr->id_offset = lseek(fd, 0, SEEK_CUR);
  1365. err = do_write(fd, attr->id, attr->ids * sizeof(u64));
  1366. if (err < 0) {
  1367. out_err_write:
  1368. pr_debug("failed to write perf header\n");
  1369. return err;
  1370. }
  1371. if (session->evlist != evlist) {
  1372. err = do_write(fd, pair->id, pair->ids * sizeof(u64));
  1373. if (err < 0)
  1374. goto out_err_write;
  1375. attr->ids += pair->ids;
  1376. pair = list_entry(pair->node.next, struct perf_evsel, node);
  1377. }
  1378. }
  1379. header->attr_offset = lseek(fd, 0, SEEK_CUR);
  1380. list_for_each_entry(attr, &evlist->entries, node) {
  1381. f_attr = (struct perf_file_attr){
  1382. .attr = attr->attr,
  1383. .ids = {
  1384. .offset = attr->id_offset,
  1385. .size = attr->ids * sizeof(u64),
  1386. }
  1387. };
  1388. err = do_write(fd, &f_attr, sizeof(f_attr));
  1389. if (err < 0) {
  1390. pr_debug("failed to write perf header attribute\n");
  1391. return err;
  1392. }
  1393. }
  1394. header->event_offset = lseek(fd, 0, SEEK_CUR);
  1395. header->event_size = event_count * sizeof(struct perf_trace_event_type);
  1396. if (events) {
  1397. err = do_write(fd, events, header->event_size);
  1398. if (err < 0) {
  1399. pr_debug("failed to write perf header events\n");
  1400. return err;
  1401. }
  1402. }
  1403. header->data_offset = lseek(fd, 0, SEEK_CUR);
  1404. if (at_exit) {
  1405. err = perf_header__adds_write(header, evlist, fd);
  1406. if (err < 0)
  1407. return err;
  1408. }
  1409. f_header = (struct perf_file_header){
  1410. .magic = PERF_MAGIC,
  1411. .size = sizeof(f_header),
  1412. .attr_size = sizeof(f_attr),
  1413. .attrs = {
  1414. .offset = header->attr_offset,
  1415. .size = evlist->nr_entries * sizeof(f_attr),
  1416. },
  1417. .data = {
  1418. .offset = header->data_offset,
  1419. .size = header->data_size,
  1420. },
  1421. .event_types = {
  1422. .offset = header->event_offset,
  1423. .size = header->event_size,
  1424. },
  1425. };
  1426. memcpy(&f_header.adds_features, &header->adds_features, sizeof(header->adds_features));
  1427. lseek(fd, 0, SEEK_SET);
  1428. err = do_write(fd, &f_header, sizeof(f_header));
  1429. if (err < 0) {
  1430. pr_debug("failed to write perf header\n");
  1431. return err;
  1432. }
  1433. lseek(fd, header->data_offset + header->data_size, SEEK_SET);
  1434. header->frozen = 1;
  1435. return 0;
  1436. }
  1437. static int perf_header__getbuffer64(struct perf_header *header,
  1438. int fd, void *buf, size_t size)
  1439. {
  1440. if (readn(fd, buf, size) <= 0)
  1441. return -1;
  1442. if (header->needs_swap)
  1443. mem_bswap_64(buf, size);
  1444. return 0;
  1445. }
  1446. int perf_header__process_sections(struct perf_header *header, int fd,
  1447. void *data,
  1448. int (*process)(struct perf_file_section *section,
  1449. struct perf_header *ph,
  1450. int feat, int fd, void *data))
  1451. {
  1452. struct perf_file_section *feat_sec, *sec;
  1453. int nr_sections;
  1454. int sec_size;
  1455. int feat;
  1456. int err;
  1457. nr_sections = bitmap_weight(header->adds_features, HEADER_FEAT_BITS);
  1458. if (!nr_sections)
  1459. return 0;
  1460. feat_sec = sec = calloc(sizeof(*feat_sec), nr_sections);
  1461. if (!feat_sec)
  1462. return -1;
  1463. sec_size = sizeof(*feat_sec) * nr_sections;
  1464. lseek(fd, header->data_offset + header->data_size, SEEK_SET);
  1465. err = perf_header__getbuffer64(header, fd, feat_sec, sec_size);
  1466. if (err < 0)
  1467. goto out_free;
  1468. for_each_set_bit(feat, header->adds_features, HEADER_LAST_FEATURE) {
  1469. err = process(sec++, header, feat, fd, data);
  1470. if (err < 0)
  1471. goto out_free;
  1472. }
  1473. err = 0;
  1474. out_free:
  1475. free(feat_sec);
  1476. return err;
  1477. }
  1478. static const int attr_file_abi_sizes[] = {
  1479. [0] = PERF_ATTR_SIZE_VER0,
  1480. [1] = PERF_ATTR_SIZE_VER1,
  1481. 0,
  1482. };
  1483. /*
  1484. * In the legacy file format, the magic number is not used to encode endianness.
  1485. * hdr_sz was used to encode endianness. But given that hdr_sz can vary based
  1486. * on ABI revisions, we need to try all combinations for all endianness to
  1487. * detect the endianness.
  1488. */
  1489. static int try_all_file_abis(uint64_t hdr_sz, struct perf_header *ph)
  1490. {
  1491. uint64_t ref_size, attr_size;
  1492. int i;
  1493. for (i = 0 ; attr_file_abi_sizes[i]; i++) {
  1494. ref_size = attr_file_abi_sizes[i]
  1495. + sizeof(struct perf_file_section);
  1496. if (hdr_sz != ref_size) {
  1497. attr_size = bswap_64(hdr_sz);
  1498. if (attr_size != ref_size)
  1499. continue;
  1500. ph->needs_swap = true;
  1501. }
  1502. pr_debug("ABI%d perf.data file detected, need_swap=%d\n",
  1503. i,
  1504. ph->needs_swap);
  1505. return 0;
  1506. }
  1507. /* could not determine endianness */
  1508. return -1;
  1509. }
  1510. #define PERF_PIPE_HDR_VER0 16
  1511. static const size_t attr_pipe_abi_sizes[] = {
  1512. [0] = PERF_PIPE_HDR_VER0,
  1513. 0,
  1514. };
  1515. /*
  1516. * In the legacy pipe format, there is an implicit assumption that endiannesss
  1517. * between host recording the samples, and host parsing the samples is the
  1518. * same. This is not always the case given that the pipe output may always be
  1519. * redirected into a file and analyzed on a different machine with possibly a
  1520. * different endianness and perf_event ABI revsions in the perf tool itself.
  1521. */
  1522. static int try_all_pipe_abis(uint64_t hdr_sz, struct perf_header *ph)
  1523. {
  1524. u64 attr_size;
  1525. int i;
  1526. for (i = 0 ; attr_pipe_abi_sizes[i]; i++) {
  1527. if (hdr_sz != attr_pipe_abi_sizes[i]) {
  1528. attr_size = bswap_64(hdr_sz);
  1529. if (attr_size != hdr_sz)
  1530. continue;
  1531. ph->needs_swap = true;
  1532. }
  1533. pr_debug("Pipe ABI%d perf.data file detected\n", i);
  1534. return 0;
  1535. }
  1536. return -1;
  1537. }
  1538. static int check_magic_endian(u64 magic, uint64_t hdr_sz,
  1539. bool is_pipe, struct perf_header *ph)
  1540. {
  1541. int ret;
  1542. /* check for legacy format */
  1543. ret = memcmp(&magic, __perf_magic1, sizeof(magic));
  1544. if (ret == 0) {
  1545. pr_debug("legacy perf.data format\n");
  1546. if (is_pipe)
  1547. return try_all_pipe_abis(hdr_sz, ph);
  1548. return try_all_file_abis(hdr_sz, ph);
  1549. }
  1550. /*
  1551. * the new magic number serves two purposes:
  1552. * - unique number to identify actual perf.data files
  1553. * - encode endianness of file
  1554. */
  1555. /* check magic number with one endianness */
  1556. if (magic == __perf_magic2)
  1557. return 0;
  1558. /* check magic number with opposite endianness */
  1559. if (magic != __perf_magic2_sw)
  1560. return -1;
  1561. ph->needs_swap = true;
  1562. return 0;
  1563. }
  1564. int perf_file_header__read(struct perf_file_header *header,
  1565. struct perf_header *ph, int fd)
  1566. {
  1567. int ret;
  1568. lseek(fd, 0, SEEK_SET);
  1569. ret = readn(fd, header, sizeof(*header));
  1570. if (ret <= 0)
  1571. return -1;
  1572. if (check_magic_endian(header->magic,
  1573. header->attr_size, false, ph) < 0) {
  1574. pr_debug("magic/endian check failed\n");
  1575. return -1;
  1576. }
  1577. if (ph->needs_swap) {
  1578. mem_bswap_64(header, offsetof(struct perf_file_header,
  1579. adds_features));
  1580. }
  1581. if (header->size != sizeof(*header)) {
  1582. /* Support the previous format */
  1583. if (header->size == offsetof(typeof(*header), adds_features))
  1584. bitmap_zero(header->adds_features, HEADER_FEAT_BITS);
  1585. else
  1586. return -1;
  1587. } else if (ph->needs_swap) {
  1588. /*
  1589. * feature bitmap is declared as an array of unsigned longs --
  1590. * not good since its size can differ between the host that
  1591. * generated the data file and the host analyzing the file.
  1592. *
  1593. * We need to handle endianness, but we don't know the size of
  1594. * the unsigned long where the file was generated. Take a best
  1595. * guess at determining it: try 64-bit swap first (ie., file
  1596. * created on a 64-bit host), and check if the hostname feature
  1597. * bit is set (this feature bit is forced on as of fbe96f2).
  1598. * If the bit is not, undo the 64-bit swap and try a 32-bit
  1599. * swap. If the hostname bit is still not set (e.g., older data
  1600. * file), punt and fallback to the original behavior --
  1601. * clearing all feature bits and setting buildid.
  1602. */
  1603. mem_bswap_64(&header->adds_features,
  1604. BITS_TO_U64(HEADER_FEAT_BITS));
  1605. if (!test_bit(HEADER_HOSTNAME, header->adds_features)) {
  1606. /* unswap as u64 */
  1607. mem_bswap_64(&header->adds_features,
  1608. BITS_TO_U64(HEADER_FEAT_BITS));
  1609. /* unswap as u32 */
  1610. mem_bswap_32(&header->adds_features,
  1611. BITS_TO_U32(HEADER_FEAT_BITS));
  1612. }
  1613. if (!test_bit(HEADER_HOSTNAME, header->adds_features)) {
  1614. bitmap_zero(header->adds_features, HEADER_FEAT_BITS);
  1615. set_bit(HEADER_BUILD_ID, header->adds_features);
  1616. }
  1617. }
  1618. memcpy(&ph->adds_features, &header->adds_features,
  1619. sizeof(ph->adds_features));
  1620. ph->event_offset = header->event_types.offset;
  1621. ph->event_size = header->event_types.size;
  1622. ph->data_offset = header->data.offset;
  1623. ph->data_size = header->data.size;
  1624. return 0;
  1625. }
  1626. static int perf_file_section__process(struct perf_file_section *section,
  1627. struct perf_header *ph,
  1628. int feat, int fd, void *data __used)
  1629. {
  1630. if (lseek(fd, section->offset, SEEK_SET) == (off_t)-1) {
  1631. pr_debug("Failed to lseek to %" PRIu64 " offset for feature "
  1632. "%d, continuing...\n", section->offset, feat);
  1633. return 0;
  1634. }
  1635. if (feat >= HEADER_LAST_FEATURE) {
  1636. pr_debug("unknown feature %d, continuing...\n", feat);
  1637. return 0;
  1638. }
  1639. if (!feat_ops[feat].process)
  1640. return 0;
  1641. return feat_ops[feat].process(section, ph, feat, fd);
  1642. }
  1643. static int perf_file_header__read_pipe(struct perf_pipe_file_header *header,
  1644. struct perf_header *ph, int fd,
  1645. bool repipe)
  1646. {
  1647. int ret;
  1648. ret = readn(fd, header, sizeof(*header));
  1649. if (ret <= 0)
  1650. return -1;
  1651. if (check_magic_endian(header->magic, header->size, true, ph) < 0) {
  1652. pr_debug("endian/magic failed\n");
  1653. return -1;
  1654. }
  1655. if (ph->needs_swap)
  1656. header->size = bswap_64(header->size);
  1657. if (repipe && do_write(STDOUT_FILENO, header, sizeof(*header)) < 0)
  1658. return -1;
  1659. return 0;
  1660. }
  1661. static int perf_header__read_pipe(struct perf_session *session, int fd)
  1662. {
  1663. struct perf_header *header = &session->header;
  1664. struct perf_pipe_file_header f_header;
  1665. if (perf_file_header__read_pipe(&f_header, header, fd,
  1666. session->repipe) < 0) {
  1667. pr_debug("incompatible file format\n");
  1668. return -EINVAL;
  1669. }
  1670. session->fd = fd;
  1671. return 0;
  1672. }
  1673. static int read_attr(int fd, struct perf_header *ph,
  1674. struct perf_file_attr *f_attr)
  1675. {
  1676. struct perf_event_attr *attr = &f_attr->attr;
  1677. size_t sz, left;
  1678. size_t our_sz = sizeof(f_attr->attr);
  1679. int ret;
  1680. memset(f_attr, 0, sizeof(*f_attr));
  1681. /* read minimal guaranteed structure */
  1682. ret = readn(fd, attr, PERF_ATTR_SIZE_VER0);
  1683. if (ret <= 0) {
  1684. pr_debug("cannot read %d bytes of header attr\n",
  1685. PERF_ATTR_SIZE_VER0);
  1686. return -1;
  1687. }
  1688. /* on file perf_event_attr size */
  1689. sz = attr->size;
  1690. if (ph->needs_swap)
  1691. sz = bswap_32(sz);
  1692. if (sz == 0) {
  1693. /* assume ABI0 */
  1694. sz = PERF_ATTR_SIZE_VER0;
  1695. } else if (sz > our_sz) {
  1696. pr_debug("file uses a more recent and unsupported ABI"
  1697. " (%zu bytes extra)\n", sz - our_sz);
  1698. return -1;
  1699. }
  1700. /* what we have not yet read and that we know about */
  1701. left = sz - PERF_ATTR_SIZE_VER0;
  1702. if (left) {
  1703. void *ptr = attr;
  1704. ptr += PERF_ATTR_SIZE_VER0;
  1705. ret = readn(fd, ptr, left);
  1706. }
  1707. /* read perf_file_section, ids are read in caller */
  1708. ret = readn(fd, &f_attr->ids, sizeof(f_attr->ids));
  1709. return ret <= 0 ? -1 : 0;
  1710. }
  1711. static int perf_evsel__set_tracepoint_name(struct perf_evsel *evsel)
  1712. {
  1713. struct event_format *event = trace_find_event(evsel->attr.config);
  1714. char bf[128];
  1715. if (event == NULL)
  1716. return -1;
  1717. snprintf(bf, sizeof(bf), "%s:%s", event->system, event->name);
  1718. evsel->name = strdup(bf);
  1719. if (event->name == NULL)
  1720. return -1;
  1721. return 0;
  1722. }
  1723. static int perf_evlist__set_tracepoint_names(struct perf_evlist *evlist)
  1724. {
  1725. struct perf_evsel *pos;
  1726. list_for_each_entry(pos, &evlist->entries, node) {
  1727. if (pos->attr.type == PERF_TYPE_TRACEPOINT &&
  1728. perf_evsel__set_tracepoint_name(pos))
  1729. return -1;
  1730. }
  1731. return 0;
  1732. }
  1733. int perf_session__read_header(struct perf_session *session, int fd)
  1734. {
  1735. struct perf_header *header = &session->header;
  1736. struct perf_file_header f_header;
  1737. struct perf_file_attr f_attr;
  1738. u64 f_id;
  1739. int nr_attrs, nr_ids, i, j;
  1740. session->evlist = perf_evlist__new(NULL, NULL);
  1741. if (session->evlist == NULL)
  1742. return -ENOMEM;
  1743. if (session->fd_pipe)
  1744. return perf_header__read_pipe(session, fd);
  1745. if (perf_file_header__read(&f_header, header, fd) < 0)
  1746. return -EINVAL;
  1747. nr_attrs = f_header.attrs.size / f_header.attr_size;
  1748. lseek(fd, f_header.attrs.offset, SEEK_SET);
  1749. for (i = 0; i < nr_attrs; i++) {
  1750. struct perf_evsel *evsel;
  1751. off_t tmp;
  1752. if (read_attr(fd, header, &f_attr) < 0)
  1753. goto out_errno;
  1754. if (header->needs_swap)
  1755. perf_event__attr_swap(&f_attr.attr);
  1756. tmp = lseek(fd, 0, SEEK_CUR);
  1757. evsel = perf_evsel__new(&f_attr.attr, i);
  1758. if (evsel == NULL)
  1759. goto out_delete_evlist;
  1760. /*
  1761. * Do it before so that if perf_evsel__alloc_id fails, this
  1762. * entry gets purged too at perf_evlist__delete().
  1763. */
  1764. perf_evlist__add(session->evlist, evsel);
  1765. nr_ids = f_attr.ids.size / sizeof(u64);
  1766. /*
  1767. * We don't have the cpu and thread maps on the header, so
  1768. * for allocating the perf_sample_id table we fake 1 cpu and
  1769. * hattr->ids threads.
  1770. */
  1771. if (perf_evsel__alloc_id(evsel, 1, nr_ids))
  1772. goto out_delete_evlist;
  1773. lseek(fd, f_attr.ids.offset, SEEK_SET);
  1774. for (j = 0; j < nr_ids; j++) {
  1775. if (perf_header__getbuffer64(header, fd, &f_id, sizeof(f_id)))
  1776. goto out_errno;
  1777. perf_evlist__id_add(session->evlist, evsel, 0, j, f_id);
  1778. }
  1779. lseek(fd, tmp, SEEK_SET);
  1780. }
  1781. symbol_conf.nr_events = nr_attrs;
  1782. if (f_header.event_types.size) {
  1783. lseek(fd, f_header.event_types.offset, SEEK_SET);
  1784. events = malloc(f_header.event_types.size);
  1785. if (events == NULL)
  1786. return -ENOMEM;
  1787. if (perf_header__getbuffer64(header, fd, events,
  1788. f_header.event_types.size))
  1789. goto out_errno;
  1790. event_count = f_header.event_types.size / sizeof(struct perf_trace_event_type);
  1791. }
  1792. perf_header__process_sections(header, fd, NULL,
  1793. perf_file_section__process);
  1794. lseek(fd, header->data_offset, SEEK_SET);
  1795. if (perf_evlist__set_tracepoint_names(session->evlist))
  1796. goto out_delete_evlist;
  1797. header->frozen = 1;
  1798. return 0;
  1799. out_errno:
  1800. return -errno;
  1801. out_delete_evlist:
  1802. perf_evlist__delete(session->evlist);
  1803. session->evlist = NULL;
  1804. return -ENOMEM;
  1805. }
  1806. int perf_event__synthesize_attr(struct perf_tool *tool,
  1807. struct perf_event_attr *attr, u16 ids, u64 *id,
  1808. perf_event__handler_t process)
  1809. {
  1810. union perf_event *ev;
  1811. size_t size;
  1812. int err;
  1813. size = sizeof(struct perf_event_attr);
  1814. size = ALIGN(size, sizeof(u64));
  1815. size += sizeof(struct perf_event_header);
  1816. size += ids * sizeof(u64);
  1817. ev = malloc(size);
  1818. if (ev == NULL)
  1819. return -ENOMEM;
  1820. ev->attr.attr = *attr;
  1821. memcpy(ev->attr.id, id, ids * sizeof(u64));
  1822. ev->attr.header.type = PERF_RECORD_HEADER_ATTR;
  1823. ev->attr.header.size = size;
  1824. err = process(tool, ev, NULL, NULL);
  1825. free(ev);
  1826. return err;
  1827. }
  1828. int perf_event__synthesize_attrs(struct perf_tool *tool,
  1829. struct perf_session *session,
  1830. perf_event__handler_t process)
  1831. {
  1832. struct perf_evsel *attr;
  1833. int err = 0;
  1834. list_for_each_entry(attr, &session->evlist->entries, node) {
  1835. err = perf_event__synthesize_attr(tool, &attr->attr, attr->ids,
  1836. attr->id, process);
  1837. if (err) {
  1838. pr_debug("failed to create perf header attribute\n");
  1839. return err;
  1840. }
  1841. }
  1842. return err;
  1843. }
  1844. int perf_event__process_attr(union perf_event *event,
  1845. struct perf_evlist **pevlist)
  1846. {
  1847. unsigned int i, ids, n_ids;
  1848. struct perf_evsel *evsel;
  1849. struct perf_evlist *evlist = *pevlist;
  1850. if (evlist == NULL) {
  1851. *pevlist = evlist = perf_evlist__new(NULL, NULL);
  1852. if (evlist == NULL)
  1853. return -ENOMEM;
  1854. }
  1855. evsel = perf_evsel__new(&event->attr.attr, evlist->nr_entries);
  1856. if (evsel == NULL)
  1857. return -ENOMEM;
  1858. perf_evlist__add(evlist, evsel);
  1859. ids = event->header.size;
  1860. ids -= (void *)&event->attr.id - (void *)event;
  1861. n_ids = ids / sizeof(u64);
  1862. /*
  1863. * We don't have the cpu and thread maps on the header, so
  1864. * for allocating the perf_sample_id table we fake 1 cpu and
  1865. * hattr->ids threads.
  1866. */
  1867. if (perf_evsel__alloc_id(evsel, 1, n_ids))
  1868. return -ENOMEM;
  1869. for (i = 0; i < n_ids; i++) {
  1870. perf_evlist__id_add(evlist, evsel, 0, i, event->attr.id[i]);
  1871. }
  1872. return 0;
  1873. }
  1874. int perf_event__synthesize_event_type(struct perf_tool *tool,
  1875. u64 event_id, char *name,
  1876. perf_event__handler_t process,
  1877. struct machine *machine)
  1878. {
  1879. union perf_event ev;
  1880. size_t size = 0;
  1881. int err = 0;
  1882. memset(&ev, 0, sizeof(ev));
  1883. ev.event_type.event_type.event_id = event_id;
  1884. memset(ev.event_type.event_type.name, 0, MAX_EVENT_NAME);
  1885. strncpy(ev.event_type.event_type.name, name, MAX_EVENT_NAME - 1);
  1886. ev.event_type.header.type = PERF_RECORD_HEADER_EVENT_TYPE;
  1887. size = strlen(ev.event_type.event_type.name);
  1888. size = ALIGN(size, sizeof(u64));
  1889. ev.event_type.header.size = sizeof(ev.event_type) -
  1890. (sizeof(ev.event_type.event_type.name) - size);
  1891. err = process(tool, &ev, NULL, machine);
  1892. return err;
  1893. }
  1894. int perf_event__synthesize_event_types(struct perf_tool *tool,
  1895. perf_event__handler_t process,
  1896. struct machine *machine)
  1897. {
  1898. struct perf_trace_event_type *type;
  1899. int i, err = 0;
  1900. for (i = 0; i < event_count; i++) {
  1901. type = &events[i];
  1902. err = perf_event__synthesize_event_type(tool, type->event_id,
  1903. type->name, process,
  1904. machine);
  1905. if (err) {
  1906. pr_debug("failed to create perf header event type\n");
  1907. return err;
  1908. }
  1909. }
  1910. return err;
  1911. }
  1912. int perf_event__process_event_type(struct perf_tool *tool __unused,
  1913. union perf_event *event)
  1914. {
  1915. if (perf_header__push_event(event->event_type.event_type.event_id,
  1916. event->event_type.event_type.name) < 0)
  1917. return -ENOMEM;
  1918. return 0;
  1919. }
  1920. int perf_event__synthesize_tracing_data(struct perf_tool *tool, int fd,
  1921. struct perf_evlist *evlist,
  1922. perf_event__handler_t process)
  1923. {
  1924. union perf_event ev;
  1925. struct tracing_data *tdata;
  1926. ssize_t size = 0, aligned_size = 0, padding;
  1927. int err __used = 0;
  1928. /*
  1929. * We are going to store the size of the data followed
  1930. * by the data contents. Since the fd descriptor is a pipe,
  1931. * we cannot seek back to store the size of the data once
  1932. * we know it. Instead we:
  1933. *
  1934. * - write the tracing data to the temp file
  1935. * - get/write the data size to pipe
  1936. * - write the tracing data from the temp file
  1937. * to the pipe
  1938. */
  1939. tdata = tracing_data_get(&evlist->entries, fd, true);
  1940. if (!tdata)
  1941. return -1;
  1942. memset(&ev, 0, sizeof(ev));
  1943. ev.tracing_data.header.type = PERF_RECORD_HEADER_TRACING_DATA;
  1944. size = tdata->size;
  1945. aligned_size = ALIGN(size, sizeof(u64));
  1946. padding = aligned_size - size;
  1947. ev.tracing_data.header.size = sizeof(ev.tracing_data);
  1948. ev.tracing_data.size = aligned_size;
  1949. process(tool, &ev, NULL, NULL);
  1950. /*
  1951. * The put function will copy all the tracing data
  1952. * stored in temp file to the pipe.
  1953. */
  1954. tracing_data_put(tdata);
  1955. write_padded(fd, NULL, 0, padding);
  1956. return aligned_size;
  1957. }
  1958. int perf_event__process_tracing_data(union perf_event *event,
  1959. struct perf_session *session)
  1960. {
  1961. ssize_t size_read, padding, size = event->tracing_data.size;
  1962. off_t offset = lseek(session->fd, 0, SEEK_CUR);
  1963. char buf[BUFSIZ];
  1964. /* setup for reading amidst mmap */
  1965. lseek(session->fd, offset + sizeof(struct tracing_data_event),
  1966. SEEK_SET);
  1967. size_read = trace_report(session->fd, session->repipe);
  1968. padding = ALIGN(size_read, sizeof(u64)) - size_read;
  1969. if (read(session->fd, buf, padding) < 0)
  1970. die("reading input file");
  1971. if (session->repipe) {
  1972. int retw = write(STDOUT_FILENO, buf, padding);
  1973. if (retw <= 0 || retw != padding)
  1974. die("repiping tracing data padding");
  1975. }
  1976. if (size_read + padding != size)
  1977. die("tracing data size mismatch");
  1978. return size_read + padding;
  1979. }
  1980. int perf_event__synthesize_build_id(struct perf_tool *tool,
  1981. struct dso *pos, u16 misc,
  1982. perf_event__handler_t process,
  1983. struct machine *machine)
  1984. {
  1985. union perf_event ev;
  1986. size_t len;
  1987. int err = 0;
  1988. if (!pos->hit)
  1989. return err;
  1990. memset(&ev, 0, sizeof(ev));
  1991. len = pos->long_name_len + 1;
  1992. len = ALIGN(len, NAME_ALIGN);
  1993. memcpy(&ev.build_id.build_id, pos->build_id, sizeof(pos->build_id));
  1994. ev.build_id.header.type = PERF_RECORD_HEADER_BUILD_ID;
  1995. ev.build_id.header.misc = misc;
  1996. ev.build_id.pid = machine->pid;
  1997. ev.build_id.header.size = sizeof(ev.build_id) + len;
  1998. memcpy(&ev.build_id.filename, pos->long_name, pos->long_name_len);
  1999. err = process(tool, &ev, NULL, machine);
  2000. return err;
  2001. }
  2002. int perf_event__process_build_id(struct perf_tool *tool __used,
  2003. union perf_event *event,
  2004. struct perf_session *session)
  2005. {
  2006. __event_process_build_id(&event->build_id,
  2007. event->build_id.filename,
  2008. session);
  2009. return 0;
  2010. }
  2011. void disable_buildid_cache(void)
  2012. {
  2013. no_buildid_cache = true;
  2014. }