[SPARC64]: Provide mmu statistics via sysfs.
[sfrench/cifs-2.6.git] / arch / sparc64 / kernel / sysfs.c
1 /* sysfs.c: Toplogy sysfs support code for sparc64.
2  *
3  * Copyright (C) 2007 David S. Miller <davem@davemloft.net>
4  */
5 #include <linux/sysdev.h>
6 #include <linux/cpu.h>
7 #include <linux/smp.h>
8 #include <linux/percpu.h>
9 #include <linux/init.h>
10
11 #include <asm/hypervisor.h>
12 #include <asm/spitfire.h>
13
14 static DEFINE_PER_CPU(struct hv_mmu_statistics, mmu_stats) __attribute__((aligned(64)));
15
16 #define SHOW_MMUSTAT_ULONG(NAME) \
17 static ssize_t show_##NAME(struct sys_device *dev, char *buf) \
18 { \
19         struct hv_mmu_statistics *p = &per_cpu(mmu_stats, dev->id); \
20         return sprintf(buf, "%lu\n", p->NAME); \
21 } \
22 static SYSDEV_ATTR(NAME, 0444, show_##NAME, NULL)
23
24 SHOW_MMUSTAT_ULONG(immu_tsb_hits_ctx0_8k_tte);
25 SHOW_MMUSTAT_ULONG(immu_tsb_ticks_ctx0_8k_tte);
26 SHOW_MMUSTAT_ULONG(immu_tsb_hits_ctx0_64k_tte);
27 SHOW_MMUSTAT_ULONG(immu_tsb_ticks_ctx0_64k_tte);
28 SHOW_MMUSTAT_ULONG(immu_tsb_hits_ctx0_4mb_tte);
29 SHOW_MMUSTAT_ULONG(immu_tsb_ticks_ctx0_4mb_tte);
30 SHOW_MMUSTAT_ULONG(immu_tsb_hits_ctx0_256mb_tte);
31 SHOW_MMUSTAT_ULONG(immu_tsb_ticks_ctx0_256mb_tte);
32 SHOW_MMUSTAT_ULONG(immu_tsb_hits_ctxnon0_8k_tte);
33 SHOW_MMUSTAT_ULONG(immu_tsb_ticks_ctxnon0_8k_tte);
34 SHOW_MMUSTAT_ULONG(immu_tsb_hits_ctxnon0_64k_tte);
35 SHOW_MMUSTAT_ULONG(immu_tsb_ticks_ctxnon0_64k_tte);
36 SHOW_MMUSTAT_ULONG(immu_tsb_hits_ctxnon0_4mb_tte);
37 SHOW_MMUSTAT_ULONG(immu_tsb_ticks_ctxnon0_4mb_tte);
38 SHOW_MMUSTAT_ULONG(immu_tsb_hits_ctxnon0_256mb_tte);
39 SHOW_MMUSTAT_ULONG(immu_tsb_ticks_ctxnon0_256mb_tte);
40 SHOW_MMUSTAT_ULONG(dmmu_tsb_hits_ctx0_8k_tte);
41 SHOW_MMUSTAT_ULONG(dmmu_tsb_ticks_ctx0_8k_tte);
42 SHOW_MMUSTAT_ULONG(dmmu_tsb_hits_ctx0_64k_tte);
43 SHOW_MMUSTAT_ULONG(dmmu_tsb_ticks_ctx0_64k_tte);
44 SHOW_MMUSTAT_ULONG(dmmu_tsb_hits_ctx0_4mb_tte);
45 SHOW_MMUSTAT_ULONG(dmmu_tsb_ticks_ctx0_4mb_tte);
46 SHOW_MMUSTAT_ULONG(dmmu_tsb_hits_ctx0_256mb_tte);
47 SHOW_MMUSTAT_ULONG(dmmu_tsb_ticks_ctx0_256mb_tte);
48 SHOW_MMUSTAT_ULONG(dmmu_tsb_hits_ctxnon0_8k_tte);
49 SHOW_MMUSTAT_ULONG(dmmu_tsb_ticks_ctxnon0_8k_tte);
50 SHOW_MMUSTAT_ULONG(dmmu_tsb_hits_ctxnon0_64k_tte);
51 SHOW_MMUSTAT_ULONG(dmmu_tsb_ticks_ctxnon0_64k_tte);
52 SHOW_MMUSTAT_ULONG(dmmu_tsb_hits_ctxnon0_4mb_tte);
53 SHOW_MMUSTAT_ULONG(dmmu_tsb_ticks_ctxnon0_4mb_tte);
54 SHOW_MMUSTAT_ULONG(dmmu_tsb_hits_ctxnon0_256mb_tte);
55 SHOW_MMUSTAT_ULONG(dmmu_tsb_ticks_ctxnon0_256mb_tte);
56
57 static struct attribute *mmu_stat_attrs[] = {
58         &attr_immu_tsb_hits_ctx0_8k_tte.attr,
59         &attr_immu_tsb_ticks_ctx0_8k_tte.attr,
60         &attr_immu_tsb_hits_ctx0_64k_tte.attr,
61         &attr_immu_tsb_ticks_ctx0_64k_tte.attr,
62         &attr_immu_tsb_hits_ctx0_4mb_tte.attr,
63         &attr_immu_tsb_ticks_ctx0_4mb_tte.attr,
64         &attr_immu_tsb_hits_ctx0_256mb_tte.attr,
65         &attr_immu_tsb_ticks_ctx0_256mb_tte.attr,
66         &attr_immu_tsb_hits_ctxnon0_8k_tte.attr,
67         &attr_immu_tsb_ticks_ctxnon0_8k_tte.attr,
68         &attr_immu_tsb_hits_ctxnon0_64k_tte.attr,
69         &attr_immu_tsb_ticks_ctxnon0_64k_tte.attr,
70         &attr_immu_tsb_hits_ctxnon0_4mb_tte.attr,
71         &attr_immu_tsb_ticks_ctxnon0_4mb_tte.attr,
72         &attr_immu_tsb_hits_ctxnon0_256mb_tte.attr,
73         &attr_immu_tsb_ticks_ctxnon0_256mb_tte.attr,
74         &attr_dmmu_tsb_hits_ctx0_8k_tte.attr,
75         &attr_dmmu_tsb_ticks_ctx0_8k_tte.attr,
76         &attr_dmmu_tsb_hits_ctx0_64k_tte.attr,
77         &attr_dmmu_tsb_ticks_ctx0_64k_tte.attr,
78         &attr_dmmu_tsb_hits_ctx0_4mb_tte.attr,
79         &attr_dmmu_tsb_ticks_ctx0_4mb_tte.attr,
80         &attr_dmmu_tsb_hits_ctx0_256mb_tte.attr,
81         &attr_dmmu_tsb_ticks_ctx0_256mb_tte.attr,
82         &attr_dmmu_tsb_hits_ctxnon0_8k_tte.attr,
83         &attr_dmmu_tsb_ticks_ctxnon0_8k_tte.attr,
84         &attr_dmmu_tsb_hits_ctxnon0_64k_tte.attr,
85         &attr_dmmu_tsb_ticks_ctxnon0_64k_tte.attr,
86         &attr_dmmu_tsb_hits_ctxnon0_4mb_tte.attr,
87         &attr_dmmu_tsb_ticks_ctxnon0_4mb_tte.attr,
88         &attr_dmmu_tsb_hits_ctxnon0_256mb_tte.attr,
89         &attr_dmmu_tsb_ticks_ctxnon0_256mb_tte.attr,
90         NULL,
91 };
92
93 static struct attribute_group mmu_stat_group = {
94         .attrs = mmu_stat_attrs,
95         .name = "mmu_stats",
96 };
97
98 /* XXX convert to rusty's on_one_cpu */
99 static unsigned long run_on_cpu(unsigned long cpu,
100                                 unsigned long (*func)(unsigned long),
101                                 unsigned long arg)
102 {
103         cpumask_t old_affinity = current->cpus_allowed;
104         unsigned long ret;
105
106         /* should return -EINVAL to userspace */
107         if (set_cpus_allowed(current, cpumask_of_cpu(cpu)))
108                 return 0;
109
110         ret = func(arg);
111
112         set_cpus_allowed(current, old_affinity);
113
114         return ret;
115 }
116
117 static unsigned long read_mmustat_enable(unsigned long junk)
118 {
119         unsigned long ra = 0;
120
121         sun4v_mmustat_info(&ra);
122
123         return ra != 0;
124 }
125
126 static unsigned long write_mmustat_enable(unsigned long val)
127 {
128         unsigned long ra, orig_ra;
129
130         if (val)
131                 ra = __pa(&per_cpu(mmu_stats, smp_processor_id()));
132         else
133                 ra = 0UL;
134
135         return sun4v_mmustat_conf(ra, &orig_ra);
136 }
137
138 static ssize_t show_mmustat_enable(struct sys_device *s, char *buf)
139 {
140         unsigned long val = run_on_cpu(s->id, read_mmustat_enable, 0);
141         return sprintf(buf, "%lx\n", val);
142 }
143
144 static ssize_t store_mmustat_enable(struct sys_device *s, const char *buf, size_t count)
145 {
146         unsigned long val, err;
147         int ret = sscanf(buf, "%ld", &val);
148
149         if (ret != 1)
150                 return -EINVAL;
151
152         err = run_on_cpu(s->id, write_mmustat_enable, val);
153         if (err)
154                 return -EIO;
155
156         return count;
157 }
158
159 static SYSDEV_ATTR(mmustat_enable, 0644, show_mmustat_enable, store_mmustat_enable);
160
161 static int mmu_stats_supported;
162
163 static int register_mmu_stats(struct sys_device *s)
164 {
165         if (!mmu_stats_supported)
166                 return 0;
167         sysdev_create_file(s, &attr_mmustat_enable);
168         return sysfs_create_group(&s->kobj, &mmu_stat_group);
169 }
170
171 #ifdef CONFIG_HOTPLUG_CPU
172 static void unregister_mmu_stats(struct sys_device *s)
173 {
174         if (!mmu_stats_supported)
175                 return;
176         sysfs_remove_group(&s->kobj, &mmu_stat_group);
177         sysdev_remove_file(s, &attr_mmustat_enable);
178 }
179 #endif
180
181 #define SHOW_CPUDATA_ULONG_NAME(NAME, MEMBER) \
182 static ssize_t show_##NAME(struct sys_device *dev, char *buf) \
183 { \
184         cpuinfo_sparc *c = &cpu_data(dev->id); \
185         return sprintf(buf, "%lu\n", c->MEMBER); \
186 }
187
188 #define SHOW_CPUDATA_UINT_NAME(NAME, MEMBER) \
189 static ssize_t show_##NAME(struct sys_device *dev, char *buf) \
190 { \
191         cpuinfo_sparc *c = &cpu_data(dev->id); \
192         return sprintf(buf, "%u\n", c->MEMBER); \
193 }
194
195 SHOW_CPUDATA_ULONG_NAME(clock_tick, clock_tick);
196 SHOW_CPUDATA_ULONG_NAME(udelay_val, udelay_val);
197 SHOW_CPUDATA_UINT_NAME(l1_dcache_size, dcache_size);
198 SHOW_CPUDATA_UINT_NAME(l1_dcache_line_size, dcache_line_size);
199 SHOW_CPUDATA_UINT_NAME(l1_icache_size, icache_size);
200 SHOW_CPUDATA_UINT_NAME(l1_icache_line_size, icache_line_size);
201 SHOW_CPUDATA_UINT_NAME(l2_cache_size, ecache_size);
202 SHOW_CPUDATA_UINT_NAME(l2_cache_line_size, ecache_line_size);
203
204 static struct sysdev_attribute cpu_core_attrs[] = {
205         _SYSDEV_ATTR(clock_tick,          0444, show_clock_tick, NULL),
206         _SYSDEV_ATTR(udelay_val,          0444, show_udelay_val, NULL),
207         _SYSDEV_ATTR(l1_dcache_size,      0444, show_l1_dcache_size, NULL),
208         _SYSDEV_ATTR(l1_dcache_line_size, 0444, show_l1_dcache_line_size, NULL),
209         _SYSDEV_ATTR(l1_icache_size,      0444, show_l1_icache_size, NULL),
210         _SYSDEV_ATTR(l1_icache_line_size, 0444, show_l1_icache_line_size, NULL),
211         _SYSDEV_ATTR(l2_cache_size,       0444, show_l2_cache_size, NULL),
212         _SYSDEV_ATTR(l2_cache_line_size,  0444, show_l2_cache_line_size, NULL),
213 };
214
215 static DEFINE_PER_CPU(struct cpu, cpu_devices);
216
217 static void register_cpu_online(unsigned int cpu)
218 {
219         struct cpu *c = &per_cpu(cpu_devices, cpu);
220         struct sys_device *s = &c->sysdev;
221         int i;
222
223         for (i = 0; i < ARRAY_SIZE(cpu_core_attrs); i++)
224                 sysdev_create_file(s, &cpu_core_attrs[i]);
225
226         register_mmu_stats(s);
227 }
228
229 #ifdef CONFIG_HOTPLUG_CPU
230 static void unregister_cpu_online(unsigned int cpu)
231 {
232         struct cpu *c = &per_cpu(cpu_devices, cpu);
233         struct sys_device *s = &c->sysdev;
234         int i;
235
236         unregister_mmu_stats(s);
237         for (i = 0; i < ARRAY_SIZE(cpu_core_attrs); i++)
238                 sysdev_remove_file(s, &cpu_core_attrs[i]);
239 }
240 #endif
241
242 static int __cpuinit sysfs_cpu_notify(struct notifier_block *self,
243                                       unsigned long action, void *hcpu)
244 {
245         unsigned int cpu = (unsigned int)(long)hcpu;
246
247         switch (action) {
248         case CPU_ONLINE:
249         case CPU_ONLINE_FROZEN:
250                 register_cpu_online(cpu);
251                 break;
252 #ifdef CONFIG_HOTPLUG_CPU
253         case CPU_DEAD:
254         case CPU_DEAD_FROZEN:
255                 unregister_cpu_online(cpu);
256                 break;
257 #endif
258         }
259         return NOTIFY_OK;
260 }
261
262 static struct notifier_block __cpuinitdata sysfs_cpu_nb = {
263         .notifier_call  = sysfs_cpu_notify,
264 };
265
266 static void __init check_mmu_stats(void)
267 {
268         unsigned long dummy1, err;
269
270         if (tlb_type != hypervisor)
271                 return;
272
273         err = sun4v_mmustat_info(&dummy1);
274         if (!err)
275                 mmu_stats_supported = 1;
276 }
277
278 static int __init topology_init(void)
279 {
280         int cpu;
281
282         check_mmu_stats();
283
284         register_cpu_notifier(&sysfs_cpu_nb);
285
286         for_each_possible_cpu(cpu) {
287                 struct cpu *c = &per_cpu(cpu_devices, cpu);
288
289                 register_cpu(c, cpu);
290                 if (cpu_online(cpu))
291                         register_cpu_online(cpu);
292         }
293
294         return 0;
295 }
296
297 subsys_initcall(topology_init);