开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Linux/Unix编程 > 查看源码
perfmon.c
资源名称：linux-2.4.20.tar.gz　[点击查看]
上传用户：jlfgdled
上传日期：2013-04-10
资源大小：33168k
文件大小：11k
源码类别：

Linux/Unix编程

开发平台：

Unix_Linux

perfmon.c：源码内容
  1. /*
  2.  * This file contains the code to configure and utilize the ppc64 pmc hardware
  3.  * Copyright (C) 2002 David Engebretsen <engebret@us.ibm.com>
  4.  */
  6. #include <asm/proc_fs.h>
  7. #include <asm/paca.h>
  8. #include <asm/iSeries/ItLpPaca.h>
  9. #include <asm/iSeries/ItLpQueue.h>
  10. #include <asm/processor.h>
  11. #include <linux/proc_fs.h>
  12. #include <linux/spinlock.h>
  13. #include <asm/pmc.h>
  14. #include <asm/uaccess.h>
  15. #include <asm/naca.h>
  16. #include <asm/perfmon.h>
  18. extern char _stext[], _etext[], _end[];
  19. struct perfmon_base_struct perfmon_base = {0, 0, 0, 0, 0, PMC_STATE_INITIAL};
  21. int alloc_perf_buffer(int size);
  22. int free_perf_buffer(void);
  23. int clear_buffers(void);
  24. void pmc_stop(void *data);
  25. void pmc_start(void *data);
  26. void pmc_touch_bolted(void *data);
  27. void dump_pmc_struct(struct perfmon_struct *perfdata);
  28. void dump_hardware_pmc_struct(void *perfdata);
  29. int  decr_profile(struct perfmon_struct *perfdata);
  30. int  pmc_profile(struct perfmon_struct *perfdata);
  31. int  pmc_set_general(struct perfmon_struct *perfdata);
  32. int  pmc_set_user_general(struct perfmon_struct *perfdata);
  33. void pmc_configure(void *data);
  35. asmlinkage int
  36. sys_perfmonctl (int cmd, void *data) 
  37. { 
  38. struct perfmon_struct *pdata;
  39. int err;
  41. printk("sys_perfmonctl: cmd = 0x%xn", cmd); 
  42. pdata = kmalloc(sizeof(struct perfmon_struct), GFP_USER);
  43. err = __copy_from_user(pdata, data, sizeof(struct perfmon_struct));
  44. switch(cmd) {
  45. case PMC_OP_ALLOC:
  46. alloc_perf_buffer(0); 
  47. break;
  48. case PMC_OP_FREE:
  49. free_perf_buffer(); 
  50. break;
  51. case PMC_OP_CLEAR:
  52. clear_buffers();
  53. break;
  54. case PMC_OP_DUMP:
  55. dump_pmc_struct(pdata);
  56. copy_to_user(data, pdata, sizeof(struct perfmon_struct));
  57. break;
  58. case PMC_OP_DUMP_HARDWARE:
  59. dump_hardware_pmc_struct(pdata);
  60. smp_call_function(dump_hardware_pmc_struct, (void *)pdata, 0, 1);
  61. break;
  62. case PMC_OP_DECR_PROFILE: /* NIA time sampling */
  63. decr_profile(pdata); 
  64. break;
  65. case PMC_OP_PMC_PROFILE:
  66. pmc_profile(pdata); 
  67. break;
  68. case PMC_OP_SET:
  69. pmc_set_general(pdata); 
  70. break;
  71. case PMC_OP_SET_USER:
  72. pmc_set_user_general(pdata); 
  73. break;
  74. default:
  75. printk("Perfmon: Unknown operationn");
  76. break;
  77. }
  79. kfree(pdata); 
  80. return 0;
  81. }
  83. int alloc_perf_buffer(int size) 
  84. {
  85. int i;
  87. printk("Perfmon: allocate buffern");
  88. if(perfmon_base.state == PMC_STATE_INITIAL) {
  89. perfmon_base.profile_length = (((unsigned long) &_etext - 
  90.    (unsigned long) &_stext) >> 2) * sizeof(int);
  91. perfmon_base.profile_buffer = (unsigned long)btmalloc(perfmon_base.profile_length);
  92. perfmon_base.trace_length = 1024*1024*16;
  93. perfmon_base.trace_buffer = (unsigned long)btmalloc(perfmon_base.trace_length);
  95. if(perfmon_base.profile_buffer && perfmon_base.trace_buffer) {
  96. memset((char *)perfmon_base.profile_buffer, 0, perfmon_base.profile_length);
  97. printk("Profile buffer created at address 0x%lx of length 0x%lxn",
  98.        perfmon_base.profile_buffer, perfmon_base.profile_length); 
  99. } else {
  100. printk("Profile buffer creation failedn");
  101. return 0;
  102. }
  104. /* Fault in the first bolted segment - it then remains in the stab for all time */
  105. pmc_touch_bolted(NULL); 
  106. smp_call_function(pmc_touch_bolted, (void *)NULL, 0, 1);
  108. for (i=0; i<MAX_PACAS; ++i) {
  109. paca[i].prof_shift = 2;
  110. paca[i].prof_len = perfmon_base.profile_length;
  111. paca[i].prof_buffer = (unsigned *)(perfmon_base.profile_buffer);
  112. paca[i].prof_stext = (unsigned *)&_stext;
  114. paca[i].prof_etext = (unsigned *)&_etext;
  115. mb();
  116. } 
  118. perfmon_base.state = PMC_STATE_READY; 
  119. }
  121. return 0;
  122. }
  124. int free_perf_buffer() 
  125. {
  126. printk("Perfmon: free buffern");
  128. if(perfmon_base.state == PMC_STATE_INITIAL) {
  129. printk("Perfmon: free buffer failed - no buffer was allocated.n"); 
  130. return -1;
  131. }
  133. btfree((void *)perfmon_base.profile_buffer); 
  134. btfree((void *)perfmon_base.trace_buffer); 
  136. perfmon_base.profile_length = 0;
  137. perfmon_base.profile_buffer = 0;
  138. perfmon_base.trace_buffer   = 0;
  139. perfmon_base.trace_length   = 0;
  140. perfmon_base.trace_end      = 0;
  141. perfmon_base.state = PMC_STATE_INITIAL; 
  143. return(0); 
  144. }
  146. int clear_buffers() 
  147. {
  148. if(perfmon_base.state == PMC_STATE_INITIAL) {
  149. printk("Perfmon: clear buffer failed - no buffer was allocated.n"); 
  150. return -1;
  151. }
  153. printk("Perfmon: clear buffern");
  155. /* Stop counters on all processors -- blocking */
  156. pmc_stop(NULL); 
  157. smp_call_function(pmc_stop, (void *)NULL, 0, 1);
  159. /* Clear the buffers */
  160. memset((char *)perfmon_base.profile_buffer, 0, perfmon_base.profile_length);
  161. memset((char *)perfmon_base.trace_buffer, 0, perfmon_base.trace_length);
  163. /* Reset the trace buffer point */
  164. perfmon_base.trace_end = 0;
  166. /* Restart counters on all processors -- blocking */
  167. pmc_start(NULL); 
  168. smp_call_function(pmc_start, (void *)NULL, 0, 1);
  170. return(0); 
  171. }
  173. void pmc_stop(void *data) 
  174. {
  175. /* Freeze all counters, leave everything else alone */
  176. mtspr( MMCR0, mfspr( MMCR0 ) | 0x80000000 );
  177. }
  179. void pmc_start(void *data) 
  180. {
  181. /* Free all counters, leave everything else alone */
  182. mtspr( MMCR0, mfspr( MMCR0 ) & 0x7fffffff );
  183. }
  185. void pmc_touch_bolted(void *data) 
  186. {
  187. volatile int touch;
  189. /* Hack to fault the buffer into the segment table */
  190. touch = *((int *)(perfmon_base.profile_buffer));
  191. }
  193. void dump_pmc_struct(struct perfmon_struct *perfdata) 
  194. {
  195. unsigned int cpu = perfdata->vdata.pmc_info.cpu, i;
  197. if(cpu > MAX_PACAS) return;
  199. printk("PMC Control Mode: 0x%lxn", perfmon_base.state);
  200. printk("PMC[1 - 2] = 0x%16.16lx 0x%16.16lxn",
  201.        paca[cpu].pmcc[0], paca[cpu].pmcc[1]);
  202. printk("PMC[3 - 4] = 0x%16.16lx 0x%16.16lxn",
  203.        paca[cpu].pmcc[2], paca[cpu].pmcc[3]);
  204. printk("PMC[5 - 6] = 0x%16.16lx 0x%16.16lxn",
  205.        paca[cpu].pmcc[4], paca[cpu].pmcc[5]);
  206. printk("PMC[7 - 8] = 0x%16.16lx 0x%16.16lxn",
  207.        paca[cpu].pmcc[6], paca[cpu].pmcc[7]);
  209. perfdata->vdata.pmc_info.mode = perfmon_base.state;
  210. for(i = 0; i < 11; i++) 
  211. perfdata->vdata.pmc_info.pmc_base[i]  = paca[cpu].pmc[i];
  213. for(i = 0; i < 8; i++) 
  214. perfdata->vdata.pmc_info.pmc_cumulative[i]  = paca[cpu].pmcc[i];
  215. }
  217. void dump_hardware_pmc_struct(void *perfdata) 
  218. {
  219. unsigned int cpu = smp_processor_id();
  221. printk("PMC[%2.2d][1 - 4]  = 0x%8.8x 0x%8.8x 0x%8.8x 0x%8.8xn",
  222.        cpu, (u32) mfspr(PMC1),(u32) mfspr(PMC2),(u32) mfspr(PMC3),(u32) mfspr(PMC4));
  223. printk("PMC[%2.2d][5 - 8]  = 0x%8.8x 0x%8.8x 0x%8.8x 0x%8.8xn",
  224.        cpu, (u32) mfspr(PMC5),(u32) mfspr(PMC6),(u32) mfspr(PMC7),(u32) mfspr(PMC8));
  225. printk("MMCR[%2.2d][0,1,A] = 0x%8.8x 0x%8.8x 0x%8.8xn",
  226.        cpu, (u32) mfspr(MMCR0),(u32) mfspr(MMCR1),(u32) mfspr(MMCRA));
  227. }
  229. int decr_profile(struct perfmon_struct *perfdata) 
  230. {
  231. int i;
  233. printk("Perfmon: NIA decrementer profilen");
  235. if(perfmon_base.state == PMC_STATE_INITIAL) {
  236. printk("Perfmon: failed - no buffer was allocated.n"); 
  237. return -1;
  238. }
  240. /* Stop counters on all processors -- blocking */
  241. pmc_stop(NULL); 
  242. smp_call_function(pmc_stop, (void *)NULL, 0, 1);
  244. for (i=0; i<MAX_PACAS; ++i) {
  245. paca[i].prof_mode = PMC_STATE_DECR_PROFILE;
  246. }
  248. perfmon_base.state = PMC_STATE_DECR_PROFILE; 
  249. mb(); 
  251. return 0;
  252. }
  254. int pmc_profile(struct perfmon_struct *perfdata) 
  255. {
  256. struct pmc_struct *pdata = &(perfdata->vdata.pmc);
  257. int i;
  259. printk("Perfmon: NIA PMC profile and CPIn");
  261. if(perfmon_base.state == PMC_STATE_INITIAL) {
  262. printk("Perfmon: failed - no buffer was allocated.n"); 
  263. return -1;
  264. }
  266. /* Stop counters on all processors -- blocking */
  267. pmc_stop(NULL); 
  268. smp_call_function(pmc_stop, (void *)NULL, 0, 1);
  270. for (i=0; i<MAX_PACAS; ++i) {
  271. paca[i].prof_mode = PMC_STATE_PROFILE_KERN;
  272. }
  273. perfmon_base.state = PMC_STATE_PROFILE_KERN; 
  275. pdata->pmc[0] = 0x7f000000;
  276. for(i = 1; i < 8; i++) 
  277. pdata->pmc[i] = 0x0;
  278. pdata->pmc[8] = 0x26000000 | (0x01 << (31 - 25) | (0x1));
  279. pdata->pmc[9] = (0x3 << (31-4)); /* Instr completed */
  280. pdata->pmc[10] = 0x00000000 | (0x1 << (31 - 30));
  282. mb();
  284. pmc_configure((void *)perfdata);
  285. smp_call_function(pmc_configure, (void *)perfdata, 0, 0);
  287. return 0;
  288. }
  290. int pmc_set_general(struct perfmon_struct *perfdata) 
  291. {
  292. int i;
  294. printk("Perfmon: PMC sampling - Generaln");
  296. if(perfmon_base.state == PMC_STATE_INITIAL) {
  297. printk("Perfmon: failed - no buffer was allocated.n"); 
  298. return -1;
  299. }
  301. /* Stop counters on all processors -- blocking */
  302. pmc_stop(NULL); 
  303. smp_call_function(pmc_stop, (void *)NULL, 0, 1);
  305. for (i=0; i<MAX_PACAS; ++i) {
  306. paca[i].prof_mode = PMC_STATE_TRACE_KERN;
  307. }
  308. perfmon_base.state = PMC_STATE_TRACE_KERN; 
  309. mb();
  311. pmc_configure((void *)perfdata);
  312. smp_call_function(pmc_configure, (void *)perfdata, 0, 0);
  314. return 0;
  315. }
  317. int pmc_set_user_general(struct perfmon_struct *perfdata) 
  318. {
  319. struct pmc_struct *pdata = &(perfdata->vdata.pmc);
  320. int pid = perfdata->header.pid;
  321. struct task_struct *task;
  322. int i;
  324. printk("Perfmon: PMC sampling - general usern");
  326. if(perfmon_base.state == PMC_STATE_INITIAL) {
  327. printk("Perfmon: failed - no buffer was allocated.n"); 
  328. return -1;
  329. }
  331. if(pid) {
  332. printk("Perfmon: pid = 0x%xn", pid);
  333. read_lock(&tasklist_lock);
  334. task = find_task_by_pid(pid);
  335. if (task) {
  336. printk("Perfmon: task = 0x%lxn", (u64) task);
  337. task->thread.regs->msr |= 0x4;
  338. #if 0
  339. for(i = 0; i < 11; i++)
  340. task->thread.pmc[i] = pdata->pmc[i];
  341. #endif
  342. } else {
  343. printk("Perfmon: task not foundn");
  344. read_unlock(&tasklist_lock);
  345. return -1;
  346. }
  347. }
  348. read_unlock(&tasklist_lock);
  350. /* Stop counters on all processors -- blocking */
  351. pmc_stop(NULL); 
  352. smp_call_function(pmc_stop, (void *)NULL, 0, 1);
  354. for (i=0; i<MAX_PACAS; ++i) {
  355. paca[i].prof_mode = PMC_STATE_TRACE_USER;
  356. }
  357. perfmon_base.state = PMC_STATE_TRACE_USER; 
  358. mb();
  360. pmc_configure((void *)perfdata);
  361. smp_call_function(pmc_configure, (void *)perfdata, 0, 0);
  363. return 0;
  364. }
  366. void pmc_configure(void *data)
  367. {
  368. struct paca_struct *lpaca = get_paca();
  369. struct perfmon_struct *perfdata = (struct perfmon_struct *)data;
  370. struct pmc_struct *pdata = &(perfdata->vdata.pmc);
  371. unsigned long cmd_rec, i;
  373. /* Indicate to hypervisor that we are using the PMCs */
  374. if(naca->platform == PLATFORM_ISERIES_LPAR)
  375. lpaca->xLpPacaPtr->xPMCRegsInUse = 1;
  377. /* Freeze all counters */
  378. mtspr( MMCR0, 0x80000000 ); mtspr( MMCR1, 0x00000000 );
  380. cmd_rec = 0xFFUL << 56;
  381. cmd_rec |= perfdata->header.type;
  382. *((unsigned long *)(perfmon_base.trace_buffer + perfmon_base.trace_end)) = cmd_rec;
  383. perfmon_base.trace_end += 8;
  385. /* Clear all the PMCs */
  386. mtspr( PMC1, 0 ); mtspr( PMC2, 0 ); mtspr( PMC3, 0 );
  387. mtspr( PMC4, 0 ); mtspr( PMC5, 0 ); mtspr( PMC6, 0 );
  388. mtspr( PMC7, 0 ); mtspr( PMC8, 0 );
  390. for(i = 0; i < 11; i++)
  391. lpaca->pmc[i]  = pdata->pmc[i];
  393. mtspr(PMC1, lpaca->pmc[0]); mtspr(PMC2, lpaca->pmc[1]);
  394. mtspr(PMC3, lpaca->pmc[2]); mtspr(PMC4, lpaca->pmc[3]);
  395. mtspr(PMC5, lpaca->pmc[4]); mtspr(PMC6, lpaca->pmc[5]);
  396. mtspr(PMC7, lpaca->pmc[6]); mtspr(PMC8, lpaca->pmc[7]);
  397. mtspr(MMCR1, lpaca->pmc[9]); mtspr(MMCRA, lpaca->pmc[10]);
  399. mb();
  401. /* Start all counters */
  402. mtspr( MMCR0, lpaca->pmc[8]);
  403. }