misc.c 13 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537
  1. // SPDX-License-Identifier: GPL-2.0-only
  2. /*
  3. * Copyright 2022, Athira Rajeev, IBM Corp.
  4. * Copyright 2022, Madhavan Srinivasan, IBM Corp.
  5. * Copyright 2022, Kajol Jain, IBM Corp.
  6. */
  7. #include <unistd.h>
  8. #include <sys/syscall.h>
  9. #include <string.h>
  10. #include <stdio.h>
  11. #include <sys/ioctl.h>
  12. #include <sys/mman.h>
  13. #include <stdlib.h>
  14. #include <ctype.h>
  15. #include "misc.h"
  16. #define PAGE_SIZE sysconf(_SC_PAGESIZE)
  17. /* Storage for platform version */
  18. int pvr;
  19. u64 platform_extended_mask;
  20. /* Mask and Shift for Event code fields */
  21. int ev_mask_pmcxsel, ev_shift_pmcxsel; //pmcxsel field
  22. int ev_mask_marked, ev_shift_marked; //marked filed
  23. int ev_mask_comb, ev_shift_comb; //combine field
  24. int ev_mask_unit, ev_shift_unit; //unit field
  25. int ev_mask_pmc, ev_shift_pmc; //pmc field
  26. int ev_mask_cache, ev_shift_cache; //Cache sel field
  27. int ev_mask_sample, ev_shift_sample; //Random sampling field
  28. int ev_mask_thd_sel, ev_shift_thd_sel; //thresh_sel field
  29. int ev_mask_thd_start, ev_shift_thd_start; //thresh_start field
  30. int ev_mask_thd_stop, ev_shift_thd_stop; //thresh_stop field
  31. int ev_mask_thd_cmp, ev_shift_thd_cmp; //thresh cmp field
  32. int ev_mask_sm, ev_shift_sm; //SDAR mode field
  33. int ev_mask_rsq, ev_shift_rsq; //radix scope qual field
  34. int ev_mask_l2l3, ev_shift_l2l3; //l2l3 sel field
  35. int ev_mask_mmcr3_src, ev_shift_mmcr3_src; //mmcr3 field
  36. static void init_ev_encodes(void)
  37. {
  38. ev_mask_pmcxsel = 0xff;
  39. ev_shift_pmcxsel = 0;
  40. ev_mask_marked = 1;
  41. ev_shift_marked = 8;
  42. ev_mask_unit = 0xf;
  43. ev_shift_unit = 12;
  44. ev_mask_pmc = 0xf;
  45. ev_shift_pmc = 16;
  46. ev_mask_sample = 0x1f;
  47. ev_shift_sample = 24;
  48. ev_mask_thd_sel = 0x7;
  49. ev_shift_thd_sel = 29;
  50. ev_mask_thd_start = 0xf;
  51. ev_shift_thd_start = 36;
  52. ev_mask_thd_stop = 0xf;
  53. ev_shift_thd_stop = 32;
  54. switch (pvr) {
  55. case POWER10:
  56. ev_mask_thd_cmp = 0x3ffff;
  57. ev_shift_thd_cmp = 0;
  58. ev_mask_rsq = 1;
  59. ev_shift_rsq = 9;
  60. ev_mask_comb = 3;
  61. ev_shift_comb = 10;
  62. ev_mask_cache = 3;
  63. ev_shift_cache = 20;
  64. ev_mask_sm = 0x3;
  65. ev_shift_sm = 22;
  66. ev_mask_l2l3 = 0x1f;
  67. ev_shift_l2l3 = 40;
  68. ev_mask_mmcr3_src = 0x7fff;
  69. ev_shift_mmcr3_src = 45;
  70. break;
  71. case POWER9:
  72. ev_mask_comb = 3;
  73. ev_shift_comb = 10;
  74. ev_mask_cache = 0xf;
  75. ev_shift_cache = 20;
  76. ev_mask_thd_cmp = 0x3ff;
  77. ev_shift_thd_cmp = 40;
  78. ev_mask_sm = 0x3;
  79. ev_shift_sm = 50;
  80. break;
  81. default:
  82. FAIL_IF_EXIT(1);
  83. }
  84. }
  85. /* Return the extended regs mask value */
  86. static u64 perf_get_platform_reg_mask(void)
  87. {
  88. if (have_hwcap2(PPC_FEATURE2_ARCH_3_1))
  89. return PERF_POWER10_MASK;
  90. if (have_hwcap2(PPC_FEATURE2_ARCH_3_00))
  91. return PERF_POWER9_MASK;
  92. return -1;
  93. }
  94. int check_extended_regs_support(void)
  95. {
  96. int fd;
  97. struct event event;
  98. event_init(&event, 0x1001e);
  99. event.attr.type = 4;
  100. event.attr.sample_period = 1;
  101. event.attr.disabled = 1;
  102. event.attr.sample_type = PERF_SAMPLE_REGS_INTR;
  103. event.attr.sample_regs_intr = platform_extended_mask;
  104. fd = event_open(&event);
  105. if (fd != -1)
  106. return 0;
  107. return -1;
  108. }
  109. int platform_check_for_tests(void)
  110. {
  111. pvr = PVR_VER(mfspr(SPRN_PVR));
  112. /*
  113. * Check for supported platforms
  114. * for sampling test
  115. */
  116. if ((pvr != POWER10) && (pvr != POWER9))
  117. goto out;
  118. /*
  119. * Check PMU driver registered by looking for
  120. * PPC_FEATURE2_EBB bit in AT_HWCAP2
  121. */
  122. if (!have_hwcap2(PPC_FEATURE2_EBB) || !have_hwcap2(PPC_FEATURE2_ARCH_3_00))
  123. goto out;
  124. return 0;
  125. out:
  126. printf("%s: Tests unsupported for this platform\n", __func__);
  127. return -1;
  128. }
  129. int check_pvr_for_sampling_tests(void)
  130. {
  131. SKIP_IF(platform_check_for_tests());
  132. platform_extended_mask = perf_get_platform_reg_mask();
  133. /* check if platform supports extended regs */
  134. if (check_extended_regs_support())
  135. goto out;
  136. init_ev_encodes();
  137. return 0;
  138. out:
  139. printf("%s: Sampling tests un-supported\n", __func__);
  140. return -1;
  141. }
  142. /*
  143. * Allocate mmap buffer of "mmap_pages" number of
  144. * pages.
  145. */
  146. void *event_sample_buf_mmap(int fd, int mmap_pages)
  147. {
  148. size_t page_size = sysconf(_SC_PAGESIZE);
  149. size_t mmap_size;
  150. void *buff;
  151. if (mmap_pages <= 0)
  152. return NULL;
  153. if (fd <= 0)
  154. return NULL;
  155. mmap_size = page_size * (1 + mmap_pages);
  156. buff = mmap(NULL, mmap_size,
  157. PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
  158. if (buff == MAP_FAILED) {
  159. perror("mmap() failed.");
  160. return NULL;
  161. }
  162. return buff;
  163. }
  164. /*
  165. * Post process the mmap buffer.
  166. * - If sample_count != NULL then return count of total
  167. * number of samples present in the mmap buffer.
  168. * - If sample_count == NULL then return the address
  169. * of first sample from the mmap buffer
  170. */
  171. void *__event_read_samples(void *sample_buff, size_t *size, u64 *sample_count)
  172. {
  173. size_t page_size = sysconf(_SC_PAGESIZE);
  174. struct perf_event_header *header = sample_buff + page_size;
  175. struct perf_event_mmap_page *metadata_page = sample_buff;
  176. unsigned long data_head, data_tail;
  177. /*
  178. * PERF_RECORD_SAMPLE:
  179. * struct {
  180. * struct perf_event_header hdr;
  181. * u64 data[];
  182. * };
  183. */
  184. data_head = metadata_page->data_head;
  185. /* sync memory before reading sample */
  186. mb();
  187. data_tail = metadata_page->data_tail;
  188. /* Check for sample_count */
  189. if (sample_count)
  190. *sample_count = 0;
  191. while (1) {
  192. /*
  193. * Reads the mmap data buffer by moving
  194. * the data_tail to know the last read data.
  195. * data_head points to head in data buffer.
  196. * refer "struct perf_event_mmap_page" in
  197. * "include/uapi/linux/perf_event.h".
  198. */
  199. if (data_head - data_tail < sizeof(header))
  200. return NULL;
  201. data_tail += sizeof(header);
  202. if (header->type == PERF_RECORD_SAMPLE) {
  203. *size = (header->size - sizeof(header));
  204. if (!sample_count)
  205. return sample_buff + page_size + data_tail;
  206. data_tail += *size;
  207. *sample_count += 1;
  208. } else {
  209. *size = (header->size - sizeof(header));
  210. if ((metadata_page->data_tail + *size) > metadata_page->data_head)
  211. data_tail = metadata_page->data_head;
  212. else
  213. data_tail += *size;
  214. }
  215. header = (struct perf_event_header *)((void *)header + header->size);
  216. }
  217. return NULL;
  218. }
  219. int collect_samples(void *sample_buff)
  220. {
  221. u64 sample_count;
  222. size_t size = 0;
  223. __event_read_samples(sample_buff, &size, &sample_count);
  224. return sample_count;
  225. }
  226. static void *perf_read_first_sample(void *sample_buff, size_t *size)
  227. {
  228. return __event_read_samples(sample_buff, size, NULL);
  229. }
  230. u64 *get_intr_regs(struct event *event, void *sample_buff)
  231. {
  232. u64 type = event->attr.sample_type;
  233. u64 *intr_regs;
  234. size_t size = 0;
  235. if ((type ^ (PERF_SAMPLE_REGS_INTR | PERF_SAMPLE_BRANCH_STACK)) &&
  236. (type ^ PERF_SAMPLE_REGS_INTR))
  237. return NULL;
  238. intr_regs = (u64 *)perf_read_first_sample(sample_buff, &size);
  239. if (!intr_regs)
  240. return NULL;
  241. if (type & PERF_SAMPLE_BRANCH_STACK) {
  242. /*
  243. * PERF_RECORD_SAMPLE and PERF_SAMPLE_BRANCH_STACK:
  244. * struct {
  245. * struct perf_event_header hdr;
  246. * u64 number_of_branches;
  247. * struct perf_branch_entry[number_of_branches];
  248. * u64 data[];
  249. * };
  250. * struct perf_branch_entry {
  251. * u64 from;
  252. * u64 to;
  253. * u64 misc;
  254. * };
  255. */
  256. intr_regs += ((*intr_regs) * 3) + 1;
  257. }
  258. /*
  259. * First entry in the sample buffer used to specify
  260. * PERF_SAMPLE_REGS_ABI_64, skip perf regs abi to access
  261. * interrupt registers.
  262. */
  263. ++intr_regs;
  264. return intr_regs;
  265. }
  266. static const int __perf_reg_mask(const char *register_name)
  267. {
  268. if (!strcmp(register_name, "R0"))
  269. return 0;
  270. else if (!strcmp(register_name, "R1"))
  271. return 1;
  272. else if (!strcmp(register_name, "R2"))
  273. return 2;
  274. else if (!strcmp(register_name, "R3"))
  275. return 3;
  276. else if (!strcmp(register_name, "R4"))
  277. return 4;
  278. else if (!strcmp(register_name, "R5"))
  279. return 5;
  280. else if (!strcmp(register_name, "R6"))
  281. return 6;
  282. else if (!strcmp(register_name, "R7"))
  283. return 7;
  284. else if (!strcmp(register_name, "R8"))
  285. return 8;
  286. else if (!strcmp(register_name, "R9"))
  287. return 9;
  288. else if (!strcmp(register_name, "R10"))
  289. return 10;
  290. else if (!strcmp(register_name, "R11"))
  291. return 11;
  292. else if (!strcmp(register_name, "R12"))
  293. return 12;
  294. else if (!strcmp(register_name, "R13"))
  295. return 13;
  296. else if (!strcmp(register_name, "R14"))
  297. return 14;
  298. else if (!strcmp(register_name, "R15"))
  299. return 15;
  300. else if (!strcmp(register_name, "R16"))
  301. return 16;
  302. else if (!strcmp(register_name, "R17"))
  303. return 17;
  304. else if (!strcmp(register_name, "R18"))
  305. return 18;
  306. else if (!strcmp(register_name, "R19"))
  307. return 19;
  308. else if (!strcmp(register_name, "R20"))
  309. return 20;
  310. else if (!strcmp(register_name, "R21"))
  311. return 21;
  312. else if (!strcmp(register_name, "R22"))
  313. return 22;
  314. else if (!strcmp(register_name, "R23"))
  315. return 23;
  316. else if (!strcmp(register_name, "R24"))
  317. return 24;
  318. else if (!strcmp(register_name, "R25"))
  319. return 25;
  320. else if (!strcmp(register_name, "R26"))
  321. return 26;
  322. else if (!strcmp(register_name, "R27"))
  323. return 27;
  324. else if (!strcmp(register_name, "R28"))
  325. return 28;
  326. else if (!strcmp(register_name, "R29"))
  327. return 29;
  328. else if (!strcmp(register_name, "R30"))
  329. return 30;
  330. else if (!strcmp(register_name, "R31"))
  331. return 31;
  332. else if (!strcmp(register_name, "NIP"))
  333. return 32;
  334. else if (!strcmp(register_name, "MSR"))
  335. return 33;
  336. else if (!strcmp(register_name, "ORIG_R3"))
  337. return 34;
  338. else if (!strcmp(register_name, "CTR"))
  339. return 35;
  340. else if (!strcmp(register_name, "LINK"))
  341. return 36;
  342. else if (!strcmp(register_name, "XER"))
  343. return 37;
  344. else if (!strcmp(register_name, "CCR"))
  345. return 38;
  346. else if (!strcmp(register_name, "SOFTE"))
  347. return 39;
  348. else if (!strcmp(register_name, "TRAP"))
  349. return 40;
  350. else if (!strcmp(register_name, "DAR"))
  351. return 41;
  352. else if (!strcmp(register_name, "DSISR"))
  353. return 42;
  354. else if (!strcmp(register_name, "SIER"))
  355. return 43;
  356. else if (!strcmp(register_name, "MMCRA"))
  357. return 44;
  358. else if (!strcmp(register_name, "MMCR0"))
  359. return 45;
  360. else if (!strcmp(register_name, "MMCR1"))
  361. return 46;
  362. else if (!strcmp(register_name, "MMCR2"))
  363. return 47;
  364. else if (!strcmp(register_name, "MMCR3"))
  365. return 48;
  366. else if (!strcmp(register_name, "SIER2"))
  367. return 49;
  368. else if (!strcmp(register_name, "SIER3"))
  369. return 50;
  370. else if (!strcmp(register_name, "PMC1"))
  371. return 51;
  372. else if (!strcmp(register_name, "PMC2"))
  373. return 52;
  374. else if (!strcmp(register_name, "PMC3"))
  375. return 53;
  376. else if (!strcmp(register_name, "PMC4"))
  377. return 54;
  378. else if (!strcmp(register_name, "PMC5"))
  379. return 55;
  380. else if (!strcmp(register_name, "PMC6"))
  381. return 56;
  382. else if (!strcmp(register_name, "SDAR"))
  383. return 57;
  384. else if (!strcmp(register_name, "SIAR"))
  385. return 58;
  386. else
  387. return -1;
  388. }
  389. u64 get_reg_value(u64 *intr_regs, char *register_name)
  390. {
  391. int register_bit_position;
  392. register_bit_position = __perf_reg_mask(register_name);
  393. if (register_bit_position < 0 || (!((platform_extended_mask >>
  394. (register_bit_position - 1)) & 1)))
  395. return -1;
  396. return *(intr_regs + register_bit_position);
  397. }
  398. int get_thresh_cmp_val(struct event event)
  399. {
  400. int exp = 0;
  401. u64 result = 0;
  402. u64 value;
  403. if (!have_hwcap2(PPC_FEATURE2_ARCH_3_1))
  404. return EV_CODE_EXTRACT(event.attr.config, thd_cmp);
  405. value = EV_CODE_EXTRACT(event.attr.config1, thd_cmp);
  406. if (!value)
  407. return value;
  408. /*
  409. * Incase of P10, thresh_cmp value is not part of raw event code
  410. * and provided via attr.config1 parameter. To program threshold in MMCRA,
  411. * take a 18 bit number N and shift right 2 places and increment
  412. * the exponent E by 1 until the upper 10 bits of N are zero.
  413. * Write E to the threshold exponent and write the lower 8 bits of N
  414. * to the threshold mantissa.
  415. * The max threshold that can be written is 261120.
  416. */
  417. if (value > 261120)
  418. value = 261120;
  419. while ((64 - __builtin_clzl(value)) > 8) {
  420. exp++;
  421. value >>= 2;
  422. }
  423. /*
  424. * Note that it is invalid to write a mantissa with the
  425. * upper 2 bits of mantissa being zero, unless the
  426. * exponent is also zero.
  427. */
  428. if (!(value & 0xC0) && exp)
  429. result = -1;
  430. else
  431. result = (exp << 8) | value;
  432. return result;
  433. }
  434. /*
  435. * Utility function to check for generic compat PMU
  436. * by comparing base_platform value from auxv and real
  437. * PVR value.
  438. */
  439. static bool auxv_generic_compat_pmu(void)
  440. {
  441. int base_pvr = 0;
  442. if (!strcmp(auxv_base_platform(), "power9"))
  443. base_pvr = POWER9;
  444. else if (!strcmp(auxv_base_platform(), "power10"))
  445. base_pvr = POWER10;
  446. return (!base_pvr);
  447. }
  448. /*
  449. * Check for generic compat PMU.
  450. * First check for presence of pmu_name from
  451. * "/sys/bus/event_source/devices/cpu/caps".
  452. * If doesn't exist, fallback to using value
  453. * auxv.
  454. */
  455. bool check_for_generic_compat_pmu(void)
  456. {
  457. char pmu_name[256];
  458. memset(pmu_name, 0, sizeof(pmu_name));
  459. if (read_sysfs_file("bus/event_source/devices/cpu/caps/pmu_name",
  460. pmu_name, sizeof(pmu_name)) < 0)
  461. return auxv_generic_compat_pmu();
  462. if (!strcmp(pmu_name, "ISAv3"))
  463. return true;
  464. else
  465. return false;
  466. }
  467. /*
  468. * Check if system is booted in compat mode.
  469. */
  470. bool check_for_compat_mode(void)
  471. {
  472. char *platform = auxv_platform();
  473. char *base_platform = auxv_base_platform();
  474. return strcmp(platform, base_platform);
  475. }