1 /* 2 * Copyright (C) 2006 Mike Kravetz IBM Corporation 3 * 4 * Hypervisor Call Instrumentation 5 * 6 * This program is free software; you can redistribute it and/or modify 7 * it under the terms of the GNU General Public License as published by 8 * the Free Software Foundation; either version 2 of the License, or 9 * (at your option) any later version. 10 * 11 * This program is distributed in the hope that it will be useful, 12 * but WITHOUT ANY WARRANTY; without even the implied warranty of 13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 14 * GNU General Public License for more details. 15 * 16 * You should have received a copy of the GNU General Public License 17 * along with this program; if not, write to the Free Software 18 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA 19 */ 20 21 #include <linux/kernel.h> 22 #include <linux/percpu.h> 23 #include <linux/debugfs.h> 24 #include <linux/seq_file.h> 25 #include <linux/cpumask.h> 26 #include <asm/hvcall.h> 27 #include <asm/firmware.h> 28 #include <asm/cputable.h> 29 #include <asm/trace.h> 30 31 DEFINE_PER_CPU(struct hcall_stats[HCALL_STAT_ARRAY_SIZE], hcall_stats); 32 33 /* 34 * Routines for displaying the statistics in debugfs 35 */ 36 static void *hc_start(struct seq_file *m, loff_t *pos) 37 { 38 if ((int)*pos < (HCALL_STAT_ARRAY_SIZE-1)) 39 return (void *)(unsigned long)(*pos + 1); 40 41 return NULL; 42 } 43 44 static void *hc_next(struct seq_file *m, void *p, loff_t * pos) 45 { 46 ++*pos; 47 48 return hc_start(m, pos); 49 } 50 51 static void hc_stop(struct seq_file *m, void *p) 52 { 53 } 54 55 static int hc_show(struct seq_file *m, void *p) 56 { 57 unsigned long h_num = (unsigned long)p; 58 struct hcall_stats *hs = (struct hcall_stats *)m->private; 59 60 if (hs[h_num].num_calls) { 61 if (cpu_has_feature(CPU_FTR_PURR)) 62 seq_printf(m, "%lu %lu %lu %lu\n", h_num<<2, 63 hs[h_num].num_calls, 64 hs[h_num].tb_total, 65 hs[h_num].purr_total); 66 else 67 seq_printf(m, "%lu %lu %lu\n", h_num<<2, 68 hs[h_num].num_calls, 69 hs[h_num].tb_total); 70 } 71 72 return 0; 73 } 74 75 static const struct seq_operations hcall_inst_seq_ops = { 76 .start = hc_start, 77 .next = hc_next, 78 .stop = hc_stop, 79 .show = hc_show 80 }; 81 82 static int hcall_inst_seq_open(struct inode *inode, struct file *file) 83 { 84 int rc; 85 struct seq_file *seq; 86 87 rc = seq_open(file, &hcall_inst_seq_ops); 88 seq = file->private_data; 89 seq->private = file->f_path.dentry->d_inode->i_private; 90 91 return rc; 92 } 93 94 static const struct file_operations hcall_inst_seq_fops = { 95 .open = hcall_inst_seq_open, 96 .read = seq_read, 97 .llseek = seq_lseek, 98 .release = seq_release, 99 }; 100 101 #define HCALL_ROOT_DIR "hcall_inst" 102 #define CPU_NAME_BUF_SIZE 32 103 104 105 static void probe_hcall_entry(void *ignored, unsigned long opcode, unsigned long *args) 106 { 107 struct hcall_stats *h; 108 109 if (opcode > MAX_HCALL_OPCODE) 110 return; 111 112 h = &get_cpu_var(hcall_stats)[opcode / 4]; 113 h->tb_start = mftb(); 114 h->purr_start = mfspr(SPRN_PURR); 115 } 116 117 static void probe_hcall_exit(void *ignored, unsigned long opcode, unsigned long retval, 118 unsigned long *retbuf) 119 { 120 struct hcall_stats *h; 121 122 if (opcode > MAX_HCALL_OPCODE) 123 return; 124 125 h = &__get_cpu_var(hcall_stats)[opcode / 4]; 126 h->num_calls++; 127 h->tb_total += mftb() - h->tb_start; 128 h->purr_total += mfspr(SPRN_PURR) - h->purr_start; 129 130 put_cpu_var(hcall_stats); 131 } 132 133 static int __init hcall_inst_init(void) 134 { 135 struct dentry *hcall_root; 136 struct dentry *hcall_file; 137 char cpu_name_buf[CPU_NAME_BUF_SIZE]; 138 int cpu; 139 140 if (!firmware_has_feature(FW_FEATURE_LPAR)) 141 return 0; 142 143 if (register_trace_hcall_entry(probe_hcall_entry, NULL)) 144 return -EINVAL; 145 146 if (register_trace_hcall_exit(probe_hcall_exit, NULL)) { 147 unregister_trace_hcall_entry(probe_hcall_entry, NULL); 148 return -EINVAL; 149 } 150 151 hcall_root = debugfs_create_dir(HCALL_ROOT_DIR, NULL); 152 if (!hcall_root) 153 return -ENOMEM; 154 155 for_each_possible_cpu(cpu) { 156 snprintf(cpu_name_buf, CPU_NAME_BUF_SIZE, "cpu%d", cpu); 157 hcall_file = debugfs_create_file(cpu_name_buf, S_IRUGO, 158 hcall_root, 159 per_cpu(hcall_stats, cpu), 160 &hcall_inst_seq_fops); 161 if (!hcall_file) 162 return -ENOMEM; 163 } 164 165 return 0; 166 } 167 __initcall(hcall_inst_init); 168