header.c 11 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548
  1. #include <sys/types.h>
  2. #include <unistd.h>
  3. #include <stdio.h>
  4. #include <stdlib.h>
  5. #include <linux/list.h>
  6. #include "util.h"
  7. #include "header.h"
  8. #include "../perf.h"
  9. #include "trace-event.h"
  10. #include "symbol.h"
  11. #include "data_map.h"
  12. #include "debug.h"
  13. /*
  14. * Create new perf.data header attribute:
  15. */
  16. struct perf_header_attr *perf_header_attr__new(struct perf_event_attr *attr)
  17. {
  18. struct perf_header_attr *self = malloc(sizeof(*self));
  19. if (self != NULL) {
  20. self->attr = *attr;
  21. self->ids = 0;
  22. self->size = 1;
  23. self->id = malloc(sizeof(u64));
  24. if (self->id == NULL) {
  25. free(self);
  26. self = NULL;
  27. }
  28. }
  29. return self;
  30. }
  31. void perf_header_attr__delete(struct perf_header_attr *self)
  32. {
  33. free(self->id);
  34. free(self);
  35. }
  36. int perf_header_attr__add_id(struct perf_header_attr *self, u64 id)
  37. {
  38. int pos = self->ids;
  39. self->ids++;
  40. if (self->ids > self->size) {
  41. int nsize = self->size * 2;
  42. u64 *nid = realloc(self->id, nsize * sizeof(u64));
  43. if (nid == NULL)
  44. return -1;
  45. self->size = nsize;
  46. self->id = nid;
  47. }
  48. self->id[pos] = id;
  49. return 0;
  50. }
  51. /*
  52. * Create new perf.data header:
  53. */
  54. struct perf_header *perf_header__new(void)
  55. {
  56. struct perf_header *self = calloc(sizeof(*self), 1);
  57. if (self != NULL) {
  58. self->size = 1;
  59. self->attr = malloc(sizeof(void *));
  60. if (self->attr == NULL) {
  61. free(self);
  62. self = NULL;
  63. }
  64. }
  65. return self;
  66. }
  67. void perf_header__delete(struct perf_header *self)
  68. {
  69. int i;
  70. for (i = 0; i < self->attrs; ++i)
  71. perf_header_attr__delete(self->attr[i]);
  72. free(self->attr);
  73. free(self);
  74. }
  75. int perf_header__add_attr(struct perf_header *self,
  76. struct perf_header_attr *attr)
  77. {
  78. if (self->frozen)
  79. return -1;
  80. if (self->attrs == self->size) {
  81. int nsize = self->size * 2;
  82. struct perf_header_attr **nattr;
  83. nattr = realloc(self->attr, nsize * sizeof(void *));
  84. if (nattr == NULL)
  85. return -1;
  86. self->size = nsize;
  87. self->attr = nattr;
  88. }
  89. self->attr[self->attrs++] = attr;
  90. return 0;
  91. }
  92. #define MAX_EVENT_NAME 64
  93. struct perf_trace_event_type {
  94. u64 event_id;
  95. char name[MAX_EVENT_NAME];
  96. };
  97. static int event_count;
  98. static struct perf_trace_event_type *events;
  99. void perf_header__push_event(u64 id, const char *name)
  100. {
  101. if (strlen(name) > MAX_EVENT_NAME)
  102. pr_warning("Event %s will be truncated\n", name);
  103. if (!events) {
  104. events = malloc(sizeof(struct perf_trace_event_type));
  105. if (!events)
  106. die("nomem");
  107. } else {
  108. events = realloc(events, (event_count + 1) * sizeof(struct perf_trace_event_type));
  109. if (!events)
  110. die("nomem");
  111. }
  112. memset(&events[event_count], 0, sizeof(struct perf_trace_event_type));
  113. events[event_count].event_id = id;
  114. strncpy(events[event_count].name, name, MAX_EVENT_NAME - 1);
  115. event_count++;
  116. }
  117. char *perf_header__find_event(u64 id)
  118. {
  119. int i;
  120. for (i = 0 ; i < event_count; i++) {
  121. if (events[i].event_id == id)
  122. return events[i].name;
  123. }
  124. return NULL;
  125. }
  126. static const char *__perf_magic = "PERFFILE";
  127. #define PERF_MAGIC (*(u64 *)__perf_magic)
  128. struct perf_file_attr {
  129. struct perf_event_attr attr;
  130. struct perf_file_section ids;
  131. };
  132. void perf_header__set_feat(struct perf_header *self, int feat)
  133. {
  134. set_bit(feat, self->adds_features);
  135. }
  136. bool perf_header__has_feat(const struct perf_header *self, int feat)
  137. {
  138. return test_bit(feat, self->adds_features);
  139. }
  140. static int do_write(int fd, const void *buf, size_t size)
  141. {
  142. while (size) {
  143. int ret = write(fd, buf, size);
  144. if (ret < 0)
  145. return -1;
  146. size -= ret;
  147. buf += ret;
  148. }
  149. return 0;
  150. }
  151. static int dsos__write_buildid_table(int fd)
  152. {
  153. struct dso *pos;
  154. list_for_each_entry(pos, &dsos, node) {
  155. struct build_id_event b;
  156. size_t len;
  157. if (!pos->has_build_id)
  158. continue;
  159. len = pos->long_name_len + 1;
  160. len = ALIGN(len, 64);
  161. memset(&b, 0, sizeof(b));
  162. memcpy(&b.build_id, pos->build_id, sizeof(pos->build_id));
  163. b.header.size = sizeof(b) + len;
  164. if (do_write(fd, &b, sizeof(b)) < 0 ||
  165. do_write(fd, pos->long_name, len) < 0)
  166. return -1;
  167. }
  168. return 0;
  169. }
  170. static void
  171. perf_header__adds_write(struct perf_header *self, int fd)
  172. {
  173. int nr_sections;
  174. struct perf_file_section *feat_sec;
  175. int sec_size;
  176. u64 sec_start;
  177. int idx = 0;
  178. if (dsos__read_build_ids())
  179. perf_header__set_feat(self, HEADER_BUILD_ID);
  180. nr_sections = bitmap_weight(self->adds_features, HEADER_FEAT_BITS);
  181. if (!nr_sections)
  182. return;
  183. feat_sec = calloc(sizeof(*feat_sec), nr_sections);
  184. if (!feat_sec)
  185. die("No memory");
  186. sec_size = sizeof(*feat_sec) * nr_sections;
  187. sec_start = self->data_offset + self->data_size;
  188. lseek(fd, sec_start + sec_size, SEEK_SET);
  189. if (perf_header__has_feat(self, HEADER_TRACE_INFO)) {
  190. struct perf_file_section *trace_sec;
  191. trace_sec = &feat_sec[idx++];
  192. /* Write trace info */
  193. trace_sec->offset = lseek(fd, 0, SEEK_CUR);
  194. read_tracing_data(fd, attrs, nr_counters);
  195. trace_sec->size = lseek(fd, 0, SEEK_CUR) - trace_sec->offset;
  196. }
  197. if (perf_header__has_feat(self, HEADER_BUILD_ID)) {
  198. struct perf_file_section *buildid_sec;
  199. buildid_sec = &feat_sec[idx++];
  200. dsos__load_kernel();
  201. /*
  202. * Read the list of loaded modules with its build_ids
  203. */
  204. dsos__load_modules();
  205. /* Write build-ids */
  206. buildid_sec->offset = lseek(fd, 0, SEEK_CUR);
  207. if (dsos__write_buildid_table(fd) < 0)
  208. die("failed to write buildid table");
  209. buildid_sec->size = lseek(fd, 0, SEEK_CUR) - buildid_sec->offset;
  210. }
  211. lseek(fd, sec_start, SEEK_SET);
  212. if (do_write(fd, feat_sec, sec_size) < 0)
  213. die("failed to write feature section");
  214. free(feat_sec);
  215. }
  216. void perf_header__write(struct perf_header *self, int fd, bool at_exit)
  217. {
  218. struct perf_file_header f_header;
  219. struct perf_file_attr f_attr;
  220. struct perf_header_attr *attr;
  221. int i;
  222. lseek(fd, sizeof(f_header), SEEK_SET);
  223. for (i = 0; i < self->attrs; i++) {
  224. attr = self->attr[i];
  225. attr->id_offset = lseek(fd, 0, SEEK_CUR);
  226. if (do_write(fd, attr->id, attr->ids * sizeof(u64)) < 0)
  227. die("failed to write perf header");
  228. }
  229. self->attr_offset = lseek(fd, 0, SEEK_CUR);
  230. for (i = 0; i < self->attrs; i++) {
  231. attr = self->attr[i];
  232. f_attr = (struct perf_file_attr){
  233. .attr = attr->attr,
  234. .ids = {
  235. .offset = attr->id_offset,
  236. .size = attr->ids * sizeof(u64),
  237. }
  238. };
  239. if (do_write(fd, &f_attr, sizeof(f_attr)) < 0)
  240. die("failed to write perf header attribute");
  241. }
  242. self->event_offset = lseek(fd, 0, SEEK_CUR);
  243. self->event_size = event_count * sizeof(struct perf_trace_event_type);
  244. if (events)
  245. if (do_write(fd, events, self->event_size) < 0)
  246. die("failed to write perf header events");
  247. self->data_offset = lseek(fd, 0, SEEK_CUR);
  248. if (at_exit)
  249. perf_header__adds_write(self, fd);
  250. f_header = (struct perf_file_header){
  251. .magic = PERF_MAGIC,
  252. .size = sizeof(f_header),
  253. .attr_size = sizeof(f_attr),
  254. .attrs = {
  255. .offset = self->attr_offset,
  256. .size = self->attrs * sizeof(f_attr),
  257. },
  258. .data = {
  259. .offset = self->data_offset,
  260. .size = self->data_size,
  261. },
  262. .event_types = {
  263. .offset = self->event_offset,
  264. .size = self->event_size,
  265. },
  266. };
  267. memcpy(&f_header.adds_features, &self->adds_features, sizeof(self->adds_features));
  268. lseek(fd, 0, SEEK_SET);
  269. if (do_write(fd, &f_header, sizeof(f_header)) < 0)
  270. die("failed to write perf header");
  271. lseek(fd, self->data_offset + self->data_size, SEEK_SET);
  272. self->frozen = 1;
  273. }
  274. static void do_read(int fd, void *buf, size_t size)
  275. {
  276. while (size) {
  277. int ret = read(fd, buf, size);
  278. if (ret < 0)
  279. die("failed to read");
  280. if (ret == 0)
  281. die("failed to read: missing data");
  282. size -= ret;
  283. buf += ret;
  284. }
  285. }
  286. int perf_header__process_sections(struct perf_header *self, int fd,
  287. int (*process)(struct perf_file_section *self,
  288. int feat, int fd))
  289. {
  290. struct perf_file_section *feat_sec;
  291. int nr_sections;
  292. int sec_size;
  293. int idx = 0;
  294. int err = 0, feat = 1;
  295. nr_sections = bitmap_weight(self->adds_features, HEADER_FEAT_BITS);
  296. if (!nr_sections)
  297. return 0;
  298. feat_sec = calloc(sizeof(*feat_sec), nr_sections);
  299. if (!feat_sec)
  300. return -1;
  301. sec_size = sizeof(*feat_sec) * nr_sections;
  302. lseek(fd, self->data_offset + self->data_size, SEEK_SET);
  303. do_read(fd, feat_sec, sec_size);
  304. while (idx < nr_sections && feat < HEADER_LAST_FEATURE) {
  305. if (perf_header__has_feat(self, feat)) {
  306. struct perf_file_section *sec = &feat_sec[idx++];
  307. err = process(sec, feat, fd);
  308. if (err < 0)
  309. break;
  310. }
  311. ++feat;
  312. }
  313. free(feat_sec);
  314. return err;
  315. };
  316. int perf_file_header__read(struct perf_file_header *self,
  317. struct perf_header *ph, int fd)
  318. {
  319. lseek(fd, 0, SEEK_SET);
  320. do_read(fd, self, sizeof(*self));
  321. if (self->magic != PERF_MAGIC ||
  322. self->attr_size != sizeof(struct perf_file_attr))
  323. return -1;
  324. if (self->size != sizeof(*self)) {
  325. /* Support the previous format */
  326. if (self->size == offsetof(typeof(*self), adds_features))
  327. bitmap_zero(self->adds_features, HEADER_FEAT_BITS);
  328. else
  329. return -1;
  330. }
  331. memcpy(&ph->adds_features, &self->adds_features,
  332. sizeof(self->adds_features));
  333. ph->event_offset = self->event_types.offset;
  334. ph->event_size = self->event_types.size;
  335. ph->data_offset = self->data.offset;
  336. ph->data_size = self->data.size;
  337. return 0;
  338. }
  339. static int perf_file_section__process(struct perf_file_section *self,
  340. int feat, int fd)
  341. {
  342. if (lseek(fd, self->offset, SEEK_SET) < 0) {
  343. pr_debug("Failed to lseek to %Ld offset for feature %d, "
  344. "continuing...\n", self->offset, feat);
  345. return 0;
  346. }
  347. switch (feat) {
  348. case HEADER_TRACE_INFO:
  349. trace_report(fd);
  350. break;
  351. case HEADER_BUILD_ID:
  352. if (perf_header__read_build_ids(fd, self->offset, self->size))
  353. pr_debug("Failed to read buildids, continuing...\n");
  354. break;
  355. default:
  356. pr_debug("unknown feature %d, continuing...\n", feat);
  357. }
  358. return 0;
  359. }
  360. int perf_header__read(struct perf_header *self, int fd)
  361. {
  362. struct perf_file_header f_header;
  363. struct perf_file_attr f_attr;
  364. u64 f_id;
  365. int nr_attrs, nr_ids, i, j;
  366. if (perf_file_header__read(&f_header, self, fd) < 0) {
  367. pr_debug("incompatible file format\n");
  368. return -EINVAL;
  369. }
  370. nr_attrs = f_header.attrs.size / sizeof(f_attr);
  371. lseek(fd, f_header.attrs.offset, SEEK_SET);
  372. for (i = 0; i < nr_attrs; i++) {
  373. struct perf_header_attr *attr;
  374. off_t tmp;
  375. do_read(fd, &f_attr, sizeof(f_attr));
  376. tmp = lseek(fd, 0, SEEK_CUR);
  377. attr = perf_header_attr__new(&f_attr.attr);
  378. if (attr == NULL)
  379. return -ENOMEM;
  380. nr_ids = f_attr.ids.size / sizeof(u64);
  381. lseek(fd, f_attr.ids.offset, SEEK_SET);
  382. for (j = 0; j < nr_ids; j++) {
  383. do_read(fd, &f_id, sizeof(f_id));
  384. if (perf_header_attr__add_id(attr, f_id) < 0) {
  385. perf_header_attr__delete(attr);
  386. return -ENOMEM;
  387. }
  388. }
  389. if (perf_header__add_attr(self, attr) < 0) {
  390. perf_header_attr__delete(attr);
  391. return -ENOMEM;
  392. }
  393. lseek(fd, tmp, SEEK_SET);
  394. }
  395. if (f_header.event_types.size) {
  396. lseek(fd, f_header.event_types.offset, SEEK_SET);
  397. events = malloc(f_header.event_types.size);
  398. if (events == NULL)
  399. return -ENOMEM;
  400. do_read(fd, events, f_header.event_types.size);
  401. event_count = f_header.event_types.size / sizeof(struct perf_trace_event_type);
  402. }
  403. perf_header__process_sections(self, fd, perf_file_section__process);
  404. lseek(fd, self->data_offset, SEEK_SET);
  405. self->frozen = 1;
  406. return 0;
  407. }
  408. u64 perf_header__sample_type(struct perf_header *header)
  409. {
  410. u64 type = 0;
  411. int i;
  412. for (i = 0; i < header->attrs; i++) {
  413. struct perf_header_attr *attr = header->attr[i];
  414. if (!type)
  415. type = attr->attr.sample_type;
  416. else if (type != attr->attr.sample_type)
  417. die("non matching sample_type");
  418. }
  419. return type;
  420. }
  421. struct perf_event_attr *
  422. perf_header__find_attr(u64 id, struct perf_header *header)
  423. {
  424. int i;
  425. for (i = 0; i < header->attrs; i++) {
  426. struct perf_header_attr *attr = header->attr[i];
  427. int j;
  428. for (j = 0; j < attr->ids; j++) {
  429. if (attr->id[j] == id)
  430. return &attr->attr;
  431. }
  432. }
  433. return NULL;
  434. }