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 #include <asm/machdep.h> 31 32 DEFINE_PER_CPU(struct hcall_stats[HCALL_STAT_ARRAY_SIZE], hcall_stats); 33 34 /* 35 * Routines for displaying the statistics in debugfs 36 */ 37 static void *hc_start(struct seq_file *m, loff_t *pos) 38 { 39 if ((int)*pos < (HCALL_STAT_ARRAY_SIZE-1)) 40 return (void *)(unsigned long)(*pos + 1); 41 42 return NULL; 43 } 44 45 static void *hc_next(struct seq_file *m, void *p, loff_t * pos) 46 { 47 ++*pos; 48 49 return hc_start(m, pos); 50 } 51 52 static void hc_stop(struct seq_file *m, void *p) 53 { 54 } 55 56 static int hc_show(struct seq_file *m, void *p) 57 { 58 unsigned long h_num = (unsigned long)p; 59 struct hcall_stats *hs = m->private; 60 61 if (hs[h_num].num_calls) { 62 if (cpu_has_feature(CPU_FTR_PURR)) 63 seq_printf(m, "%lu %lu %lu %lu\n", h_num<<2, 64 hs[h_num].num_calls, 65 hs[h_num].tb_total, 66 hs[h_num].purr_total); 67 else 68 seq_printf(m, "%lu %lu %lu\n", h_num<<2, 69 hs[h_num].num_calls, 70 hs[h_num].tb_total); 71 } 72 73 return 0; 74 } 75 76 static const struct seq_operations hcall_inst_seq_ops = { 77 .start = hc_start, 78 .next = hc_next, 79 .stop = hc_stop, 80 .show = hc_show 81 }; 82 83 static int hcall_inst_seq_open(struct inode *inode, struct file *file) 84 { 85 int rc; 86 struct seq_file *seq; 87 88 rc = seq_open(file, &hcall_inst_seq_ops); 89 seq = file->private_data; 90 seq->private = file_inode(file)->i_private; 91 92 return rc; 93 } 94 95 static const struct file_operations hcall_inst_seq_fops = { 96 .open = hcall_inst_seq_open, 97 .read = seq_read, 98 .llseek = seq_lseek, 99 .release = seq_release, 100 }; 101 102 #define HCALL_ROOT_DIR "hcall_inst" 103 #define CPU_NAME_BUF_SIZE 32 104 105 106 static void probe_hcall_entry(void *ignored, unsigned long opcode, unsigned long *args) 107 { 108 struct hcall_stats *h; 109 110 if (opcode > MAX_HCALL_OPCODE) 111 return; 112 113 h = this_cpu_ptr(&hcall_stats[opcode / 4]); 114 h->tb_start = mftb(); 115 h->purr_start = mfspr(SPRN_PURR); 116 } 117 118 static void probe_hcall_exit(void *ignored, unsigned long opcode, unsigned long retval, 119 unsigned long *retbuf) 120 { 121 struct hcall_stats *h; 122 123 if (opcode > MAX_HCALL_OPCODE) 124 return; 125 126 h = this_cpu_ptr(&hcall_stats[opcode / 4]); 127 h->num_calls++; 128 h->tb_total += mftb() - h->tb_start; 129 h->purr_total += mfspr(SPRN_PURR) - h->purr_start; 130 } 131 132 static int __init hcall_inst_init(void) 133 { 134 struct dentry *hcall_root; 135 struct dentry *hcall_file; 136 char cpu_name_buf[CPU_NAME_BUF_SIZE]; 137 int cpu; 138 139 if (!firmware_has_feature(FW_FEATURE_LPAR)) 140 return 0; 141 142 if (register_trace_hcall_entry(probe_hcall_entry, NULL)) 143 return -EINVAL; 144 145 if (register_trace_hcall_exit(probe_hcall_exit, NULL)) { 146 unregister_trace_hcall_entry(probe_hcall_entry, NULL); 147 return -EINVAL; 148 } 149 150 hcall_root = debugfs_create_dir(HCALL_ROOT_DIR, NULL); 151 if (!hcall_root) 152 return -ENOMEM; 153 154 for_each_possible_cpu(cpu) { 155 snprintf(cpu_name_buf, CPU_NAME_BUF_SIZE, "cpu%d", cpu); 156 hcall_file = debugfs_create_file(cpu_name_buf, S_IRUGO, 157 hcall_root, 158 per_cpu(hcall_stats, cpu), 159 &hcall_inst_seq_fops); 160 if (!hcall_file) 161 return -ENOMEM; 162 } 163 164 return 0; 165 } 166 machine_device_initcall(pseries, hcall_inst_init); 167