Merge branch 'ipi-for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/tip...
[linux-2.6] / arch / x86 / kernel / cpu / cpu_debug.c
1 /*
2  * CPU x86 architecture debug code
3  *
4  * Copyright(C) 2009 Jaswinder Singh Rajput
5  *
6  * For licencing details see kernel-base/COPYING
7  */
8
9 #include <linux/interrupt.h>
10 #include <linux/compiler.h>
11 #include <linux/seq_file.h>
12 #include <linux/debugfs.h>
13 #include <linux/kprobes.h>
14 #include <linux/uaccess.h>
15 #include <linux/kernel.h>
16 #include <linux/module.h>
17 #include <linux/percpu.h>
18 #include <linux/signal.h>
19 #include <linux/errno.h>
20 #include <linux/sched.h>
21 #include <linux/types.h>
22 #include <linux/init.h>
23 #include <linux/slab.h>
24 #include <linux/smp.h>
25
26 #include <asm/cpu_debug.h>
27 #include <asm/paravirt.h>
28 #include <asm/system.h>
29 #include <asm/traps.h>
30 #include <asm/apic.h>
31 #include <asm/desc.h>
32
33 static DEFINE_PER_CPU(struct cpu_cpuX_base, cpu_arr[CPU_REG_ALL_BIT]);
34 static DEFINE_PER_CPU(struct cpu_private *, priv_arr[MAX_CPU_FILES]);
35 static DEFINE_PER_CPU(unsigned, cpu_modelflag);
36 static DEFINE_PER_CPU(int, cpu_priv_count);
37 static DEFINE_PER_CPU(unsigned, cpu_model);
38
39 static DEFINE_MUTEX(cpu_debug_lock);
40
41 static struct dentry *cpu_debugfs_dir;
42
43 static struct cpu_debug_base cpu_base[] = {
44         { "mc",         CPU_MC,         0       },
45         { "monitor",    CPU_MONITOR,    0       },
46         { "time",       CPU_TIME,       0       },
47         { "pmc",        CPU_PMC,        1       },
48         { "platform",   CPU_PLATFORM,   0       },
49         { "apic",       CPU_APIC,       0       },
50         { "poweron",    CPU_POWERON,    0       },
51         { "control",    CPU_CONTROL,    0       },
52         { "features",   CPU_FEATURES,   0       },
53         { "lastbranch", CPU_LBRANCH,    0       },
54         { "bios",       CPU_BIOS,       0       },
55         { "freq",       CPU_FREQ,       0       },
56         { "mtrr",       CPU_MTRR,       0       },
57         { "perf",       CPU_PERF,       0       },
58         { "cache",      CPU_CACHE,      0       },
59         { "sysenter",   CPU_SYSENTER,   0       },
60         { "therm",      CPU_THERM,      0       },
61         { "misc",       CPU_MISC,       0       },
62         { "debug",      CPU_DEBUG,      0       },
63         { "pat",        CPU_PAT,        0       },
64         { "vmx",        CPU_VMX,        0       },
65         { "call",       CPU_CALL,       0       },
66         { "base",       CPU_BASE,       0       },
67         { "ver",        CPU_VER,        0       },
68         { "conf",       CPU_CONF,       0       },
69         { "smm",        CPU_SMM,        0       },
70         { "svm",        CPU_SVM,        0       },
71         { "osvm",       CPU_OSVM,       0       },
72         { "tss",        CPU_TSS,        0       },
73         { "cr",         CPU_CR,         0       },
74         { "dt",         CPU_DT,         0       },
75         { "registers",  CPU_REG_ALL,    0       },
76 };
77
78 static struct cpu_file_base cpu_file[] = {
79         { "index",      CPU_REG_ALL,    0       },
80         { "value",      CPU_REG_ALL,    1       },
81 };
82
83 /* Intel Registers Range */
84 static struct cpu_debug_range cpu_intel_range[] = {
85         { 0x00000000, 0x00000001, CPU_MC,       CPU_INTEL_ALL           },
86         { 0x00000006, 0x00000007, CPU_MONITOR,  CPU_CX_AT_XE            },
87         { 0x00000010, 0x00000010, CPU_TIME,     CPU_INTEL_ALL           },
88         { 0x00000011, 0x00000013, CPU_PMC,      CPU_INTEL_PENTIUM       },
89         { 0x00000017, 0x00000017, CPU_PLATFORM, CPU_PX_CX_AT_XE         },
90         { 0x0000001B, 0x0000001B, CPU_APIC,     CPU_P6_CX_AT_XE         },
91
92         { 0x0000002A, 0x0000002A, CPU_POWERON,  CPU_PX_CX_AT_XE         },
93         { 0x0000002B, 0x0000002B, CPU_POWERON,  CPU_INTEL_XEON          },
94         { 0x0000002C, 0x0000002C, CPU_FREQ,     CPU_INTEL_XEON          },
95         { 0x0000003A, 0x0000003A, CPU_CONTROL,  CPU_CX_AT_XE            },
96
97         { 0x00000040, 0x00000043, CPU_LBRANCH,  CPU_PM_CX_AT_XE         },
98         { 0x00000044, 0x00000047, CPU_LBRANCH,  CPU_PM_CO_AT            },
99         { 0x00000060, 0x00000063, CPU_LBRANCH,  CPU_C2_AT               },
100         { 0x00000064, 0x00000067, CPU_LBRANCH,  CPU_INTEL_ATOM          },
101
102         { 0x00000079, 0x00000079, CPU_BIOS,     CPU_P6_CX_AT_XE         },
103         { 0x00000088, 0x0000008A, CPU_CACHE,    CPU_INTEL_P6            },
104         { 0x0000008B, 0x0000008B, CPU_BIOS,     CPU_P6_CX_AT_XE         },
105         { 0x0000009B, 0x0000009B, CPU_MONITOR,  CPU_INTEL_XEON          },
106
107         { 0x000000C1, 0x000000C2, CPU_PMC,      CPU_P6_CX_AT            },
108         { 0x000000CD, 0x000000CD, CPU_FREQ,     CPU_CX_AT               },
109         { 0x000000E7, 0x000000E8, CPU_PERF,     CPU_CX_AT               },
110         { 0x000000FE, 0x000000FE, CPU_MTRR,     CPU_P6_CX_XE            },
111
112         { 0x00000116, 0x00000116, CPU_CACHE,    CPU_INTEL_P6            },
113         { 0x00000118, 0x00000118, CPU_CACHE,    CPU_INTEL_P6            },
114         { 0x00000119, 0x00000119, CPU_CACHE,    CPU_INTEL_PX            },
115         { 0x0000011A, 0x0000011B, CPU_CACHE,    CPU_INTEL_P6            },
116         { 0x0000011E, 0x0000011E, CPU_CACHE,    CPU_PX_CX_AT            },
117
118         { 0x00000174, 0x00000176, CPU_SYSENTER, CPU_P6_CX_AT_XE         },
119         { 0x00000179, 0x0000017A, CPU_MC,       CPU_PX_CX_AT_XE         },
120         { 0x0000017B, 0x0000017B, CPU_MC,       CPU_P6_XE               },
121         { 0x00000186, 0x00000187, CPU_PMC,      CPU_P6_CX_AT            },
122         { 0x00000198, 0x00000199, CPU_PERF,     CPU_PM_CX_AT_XE         },
123         { 0x0000019A, 0x0000019A, CPU_TIME,     CPU_PM_CX_AT_XE         },
124         { 0x0000019B, 0x0000019D, CPU_THERM,    CPU_PM_CX_AT_XE         },
125         { 0x000001A0, 0x000001A0, CPU_MISC,     CPU_PM_CX_AT_XE         },
126
127         { 0x000001C9, 0x000001C9, CPU_LBRANCH,  CPU_PM_CX_AT            },
128         { 0x000001D7, 0x000001D8, CPU_LBRANCH,  CPU_INTEL_XEON          },
129         { 0x000001D9, 0x000001D9, CPU_DEBUG,    CPU_CX_AT_XE            },
130         { 0x000001DA, 0x000001DA, CPU_LBRANCH,  CPU_INTEL_XEON          },
131         { 0x000001DB, 0x000001DB, CPU_LBRANCH,  CPU_P6_XE               },
132         { 0x000001DC, 0x000001DC, CPU_LBRANCH,  CPU_INTEL_P6            },
133         { 0x000001DD, 0x000001DE, CPU_LBRANCH,  CPU_PX_CX_AT_XE         },
134         { 0x000001E0, 0x000001E0, CPU_LBRANCH,  CPU_INTEL_P6            },
135
136         { 0x00000200, 0x0000020F, CPU_MTRR,     CPU_P6_CX_XE            },
137         { 0x00000250, 0x00000250, CPU_MTRR,     CPU_P6_CX_XE            },
138         { 0x00000258, 0x00000259, CPU_MTRR,     CPU_P6_CX_XE            },
139         { 0x00000268, 0x0000026F, CPU_MTRR,     CPU_P6_CX_XE            },
140         { 0x00000277, 0x00000277, CPU_PAT,      CPU_C2_AT_XE            },
141         { 0x000002FF, 0x000002FF, CPU_MTRR,     CPU_P6_CX_XE            },
142
143         { 0x00000300, 0x00000308, CPU_PMC,      CPU_INTEL_XEON          },
144         { 0x00000309, 0x0000030B, CPU_PMC,      CPU_C2_AT_XE            },
145         { 0x0000030C, 0x00000311, CPU_PMC,      CPU_INTEL_XEON          },
146         { 0x00000345, 0x00000345, CPU_PMC,      CPU_C2_AT               },
147         { 0x00000360, 0x00000371, CPU_PMC,      CPU_INTEL_XEON          },
148         { 0x0000038D, 0x00000390, CPU_PMC,      CPU_C2_AT               },
149         { 0x000003A0, 0x000003BE, CPU_PMC,      CPU_INTEL_XEON          },
150         { 0x000003C0, 0x000003CD, CPU_PMC,      CPU_INTEL_XEON          },
151         { 0x000003E0, 0x000003E1, CPU_PMC,      CPU_INTEL_XEON          },
152         { 0x000003F0, 0x000003F0, CPU_PMC,      CPU_INTEL_XEON          },
153         { 0x000003F1, 0x000003F1, CPU_PMC,      CPU_C2_AT_XE            },
154         { 0x000003F2, 0x000003F2, CPU_PMC,      CPU_INTEL_XEON          },
155
156         { 0x00000400, 0x00000402, CPU_MC,       CPU_PM_CX_AT_XE         },
157         { 0x00000403, 0x00000403, CPU_MC,       CPU_INTEL_XEON          },
158         { 0x00000404, 0x00000406, CPU_MC,       CPU_PM_CX_AT_XE         },
159         { 0x00000407, 0x00000407, CPU_MC,       CPU_INTEL_XEON          },
160         { 0x00000408, 0x0000040A, CPU_MC,       CPU_PM_CX_AT_XE         },
161         { 0x0000040B, 0x0000040B, CPU_MC,       CPU_INTEL_XEON          },
162         { 0x0000040C, 0x0000040E, CPU_MC,       CPU_PM_CX_XE            },
163         { 0x0000040F, 0x0000040F, CPU_MC,       CPU_INTEL_XEON          },
164         { 0x00000410, 0x00000412, CPU_MC,       CPU_PM_CX_AT_XE         },
165         { 0x00000413, 0x00000417, CPU_MC,       CPU_CX_AT_XE            },
166         { 0x00000480, 0x0000048B, CPU_VMX,      CPU_CX_AT_XE            },
167
168         { 0x00000600, 0x00000600, CPU_DEBUG,    CPU_PM_CX_AT_XE         },
169         { 0x00000680, 0x0000068F, CPU_LBRANCH,  CPU_INTEL_XEON          },
170         { 0x000006C0, 0x000006CF, CPU_LBRANCH,  CPU_INTEL_XEON          },
171
172         { 0x000107CC, 0x000107D3, CPU_PMC,      CPU_INTEL_XEON_MP       },
173
174         { 0xC0000080, 0xC0000080, CPU_FEATURES, CPU_INTEL_XEON          },
175         { 0xC0000081, 0xC0000082, CPU_CALL,     CPU_INTEL_XEON          },
176         { 0xC0000084, 0xC0000084, CPU_CALL,     CPU_INTEL_XEON          },
177         { 0xC0000100, 0xC0000102, CPU_BASE,     CPU_INTEL_XEON          },
178 };
179
180 /* AMD Registers Range */
181 static struct cpu_debug_range cpu_amd_range[] = {
182         { 0x00000000, 0x00000001, CPU_MC,       CPU_K10_PLUS,           },
183         { 0x00000010, 0x00000010, CPU_TIME,     CPU_K8_PLUS,            },
184         { 0x0000001B, 0x0000001B, CPU_APIC,     CPU_K8_PLUS,            },
185         { 0x0000002A, 0x0000002A, CPU_POWERON,  CPU_K7_PLUS             },
186         { 0x0000008B, 0x0000008B, CPU_VER,      CPU_K8_PLUS             },
187         { 0x000000FE, 0x000000FE, CPU_MTRR,     CPU_K8_PLUS,            },
188
189         { 0x00000174, 0x00000176, CPU_SYSENTER, CPU_K8_PLUS,            },
190         { 0x00000179, 0x0000017B, CPU_MC,       CPU_K8_PLUS,            },
191         { 0x000001D9, 0x000001D9, CPU_DEBUG,    CPU_K8_PLUS,            },
192         { 0x000001DB, 0x000001DE, CPU_LBRANCH,  CPU_K8_PLUS,            },
193
194         { 0x00000200, 0x0000020F, CPU_MTRR,     CPU_K8_PLUS,            },
195         { 0x00000250, 0x00000250, CPU_MTRR,     CPU_K8_PLUS,            },
196         { 0x00000258, 0x00000259, CPU_MTRR,     CPU_K8_PLUS,            },
197         { 0x00000268, 0x0000026F, CPU_MTRR,     CPU_K8_PLUS,            },
198         { 0x00000277, 0x00000277, CPU_PAT,      CPU_K8_PLUS,            },
199         { 0x000002FF, 0x000002FF, CPU_MTRR,     CPU_K8_PLUS,            },
200
201         { 0x00000400, 0x00000413, CPU_MC,       CPU_K8_PLUS,            },
202
203         { 0xC0000080, 0xC0000080, CPU_FEATURES, CPU_AMD_ALL,            },
204         { 0xC0000081, 0xC0000084, CPU_CALL,     CPU_K8_PLUS,            },
205         { 0xC0000100, 0xC0000102, CPU_BASE,     CPU_K8_PLUS,            },
206         { 0xC0000103, 0xC0000103, CPU_TIME,     CPU_K10_PLUS,           },
207
208         { 0xC0010000, 0xC0010007, CPU_PMC,      CPU_K8_PLUS,            },
209         { 0xC0010010, 0xC0010010, CPU_CONF,     CPU_K7_PLUS,            },
210         { 0xC0010015, 0xC0010015, CPU_CONF,     CPU_K7_PLUS,            },
211         { 0xC0010016, 0xC001001A, CPU_MTRR,     CPU_K8_PLUS,            },
212         { 0xC001001D, 0xC001001D, CPU_MTRR,     CPU_K8_PLUS,            },
213         { 0xC001001F, 0xC001001F, CPU_CONF,     CPU_K8_PLUS,            },
214         { 0xC0010030, 0xC0010035, CPU_BIOS,     CPU_K8_PLUS,            },
215         { 0xC0010044, 0xC0010048, CPU_MC,       CPU_K8_PLUS,            },
216         { 0xC0010050, 0xC0010056, CPU_SMM,      CPU_K0F_PLUS,           },
217         { 0xC0010058, 0xC0010058, CPU_CONF,     CPU_K10_PLUS,           },
218         { 0xC0010060, 0xC0010060, CPU_CACHE,    CPU_AMD_11,             },
219         { 0xC0010061, 0xC0010068, CPU_SMM,      CPU_K10_PLUS,           },
220         { 0xC0010069, 0xC001006B, CPU_SMM,      CPU_AMD_11,             },
221         { 0xC0010070, 0xC0010071, CPU_SMM,      CPU_K10_PLUS,           },
222         { 0xC0010111, 0xC0010113, CPU_SMM,      CPU_K8_PLUS,            },
223         { 0xC0010114, 0xC0010118, CPU_SVM,      CPU_K10_PLUS,           },
224         { 0xC0010140, 0xC0010141, CPU_OSVM,     CPU_K10_PLUS,           },
225         { 0xC0011022, 0xC0011023, CPU_CONF,     CPU_K10_PLUS,           },
226 };
227
228
229 /* Intel */
230 static int get_intel_modelflag(unsigned model)
231 {
232         int flag;
233
234         switch (model) {
235         case 0x0501:
236         case 0x0502:
237         case 0x0504:
238                 flag = CPU_INTEL_PENTIUM;
239                 break;
240         case 0x0601:
241         case 0x0603:
242         case 0x0605:
243         case 0x0607:
244         case 0x0608:
245         case 0x060A:
246         case 0x060B:
247                 flag = CPU_INTEL_P6;
248                 break;
249         case 0x0609:
250         case 0x060D:
251                 flag = CPU_INTEL_PENTIUM_M;
252                 break;
253         case 0x060E:
254                 flag = CPU_INTEL_CORE;
255                 break;
256         case 0x060F:
257         case 0x0617:
258                 flag = CPU_INTEL_CORE2;
259                 break;
260         case 0x061C:
261                 flag = CPU_INTEL_ATOM;
262                 break;
263         case 0x0F00:
264         case 0x0F01:
265         case 0x0F02:
266         case 0x0F03:
267         case 0x0F04:
268                 flag = CPU_INTEL_XEON_P4;
269                 break;
270         case 0x0F06:
271                 flag = CPU_INTEL_XEON_MP;
272                 break;
273         default:
274                 flag = CPU_NONE;
275                 break;
276         }
277
278         return flag;
279 }
280
281 /* AMD */
282 static int get_amd_modelflag(unsigned model)
283 {
284         int flag;
285
286         switch (model >> 8) {
287         case 0x6:
288                 flag = CPU_AMD_K6;
289                 break;
290         case 0x7:
291                 flag = CPU_AMD_K7;
292                 break;
293         case 0x8:
294                 flag = CPU_AMD_K8;
295                 break;
296         case 0xf:
297                 flag = CPU_AMD_0F;
298                 break;
299         case 0x10:
300                 flag = CPU_AMD_10;
301                 break;
302         case 0x11:
303                 flag = CPU_AMD_11;
304                 break;
305         default:
306                 flag = CPU_NONE;
307                 break;
308         }
309
310         return flag;
311 }
312
313 static int get_cpu_modelflag(unsigned cpu)
314 {
315         int flag;
316
317         flag = per_cpu(cpu_model, cpu);
318
319         switch (flag >> 16) {
320         case X86_VENDOR_INTEL:
321                 flag = get_intel_modelflag(flag);
322                 break;
323         case X86_VENDOR_AMD:
324                 flag = get_amd_modelflag(flag & 0xffff);
325                 break;
326         default:
327                 flag = CPU_NONE;
328                 break;
329         }
330
331         return flag;
332 }
333
334 static int get_cpu_range_count(unsigned cpu)
335 {
336         int index;
337
338         switch (per_cpu(cpu_model, cpu) >> 16) {
339         case X86_VENDOR_INTEL:
340                 index = ARRAY_SIZE(cpu_intel_range);
341                 break;
342         case X86_VENDOR_AMD:
343                 index = ARRAY_SIZE(cpu_amd_range);
344                 break;
345         default:
346                 index = 0;
347                 break;
348         }
349
350         return index;
351 }
352
353 static int is_typeflag_valid(unsigned cpu, unsigned flag)
354 {
355         unsigned vendor, modelflag;
356         int i, index;
357
358         /* Standard Registers should be always valid */
359         if (flag >= CPU_TSS)
360                 return 1;
361
362         modelflag = per_cpu(cpu_modelflag, cpu);
363         vendor = per_cpu(cpu_model, cpu) >> 16;
364         index = get_cpu_range_count(cpu);
365
366         for (i = 0; i < index; i++) {
367                 switch (vendor) {
368                 case X86_VENDOR_INTEL:
369                         if ((cpu_intel_range[i].model & modelflag) &&
370                             (cpu_intel_range[i].flag & flag))
371                                 return 1;
372                         break;
373                 case X86_VENDOR_AMD:
374                         if ((cpu_amd_range[i].model & modelflag) &&
375                             (cpu_amd_range[i].flag & flag))
376                                 return 1;
377                         break;
378                 }
379         }
380
381         /* Invalid */
382         return 0;
383 }
384
385 static unsigned get_cpu_range(unsigned cpu, unsigned *min, unsigned *max,
386                               int index, unsigned flag)
387 {
388         unsigned modelflag;
389
390         modelflag = per_cpu(cpu_modelflag, cpu);
391         *max = 0;
392         switch (per_cpu(cpu_model, cpu) >> 16) {
393         case X86_VENDOR_INTEL:
394                 if ((cpu_intel_range[index].model & modelflag) &&
395                     (cpu_intel_range[index].flag & flag)) {
396                         *min = cpu_intel_range[index].min;
397                         *max = cpu_intel_range[index].max;
398                 }
399                 break;
400         case X86_VENDOR_AMD:
401                 if ((cpu_amd_range[index].model & modelflag) &&
402                     (cpu_amd_range[index].flag & flag)) {
403                         *min = cpu_amd_range[index].min;
404                         *max = cpu_amd_range[index].max;
405                 }
406                 break;
407         }
408
409         return *max;
410 }
411
412 /* This function can also be called with seq = NULL for printk */
413 static void print_cpu_data(struct seq_file *seq, unsigned type,
414                            u32 low, u32 high)
415 {
416         struct cpu_private *priv;
417         u64 val = high;
418
419         if (seq) {
420                 priv = seq->private;
421                 if (priv->file) {
422                         val = (val << 32) | low;
423                         seq_printf(seq, "0x%llx\n", val);
424                 } else
425                         seq_printf(seq, " %08x: %08x_%08x\n",
426                                    type, high, low);
427         } else
428                 printk(KERN_INFO " %08x: %08x_%08x\n", type, high, low);
429 }
430
431 /* This function can also be called with seq = NULL for printk */
432 static void print_msr(struct seq_file *seq, unsigned cpu, unsigned flag)
433 {
434         unsigned msr, msr_min, msr_max;
435         struct cpu_private *priv;
436         u32 low, high;
437         int i, range;
438
439         if (seq) {
440                 priv = seq->private;
441                 if (priv->file) {
442                         if (!rdmsr_safe_on_cpu(priv->cpu, priv->reg,
443                                                &low, &high))
444                                 print_cpu_data(seq, priv->reg, low, high);
445                         return;
446                 }
447         }
448
449         range = get_cpu_range_count(cpu);
450
451         for (i = 0; i < range; i++) {
452                 if (!get_cpu_range(cpu, &msr_min, &msr_max, i, flag))
453                         continue;
454
455                 for (msr = msr_min; msr <= msr_max; msr++) {
456                         if (rdmsr_safe_on_cpu(cpu, msr, &low, &high))
457                                 continue;
458                         print_cpu_data(seq, msr, low, high);
459                 }
460         }
461 }
462
463 static void print_tss(void *arg)
464 {
465         struct pt_regs *regs = task_pt_regs(current);
466         struct seq_file *seq = arg;
467         unsigned int seg;
468
469         seq_printf(seq, " RAX\t: %016lx\n", regs->ax);
470         seq_printf(seq, " RBX\t: %016lx\n", regs->bx);
471         seq_printf(seq, " RCX\t: %016lx\n", regs->cx);
472         seq_printf(seq, " RDX\t: %016lx\n", regs->dx);
473
474         seq_printf(seq, " RSI\t: %016lx\n", regs->si);
475         seq_printf(seq, " RDI\t: %016lx\n", regs->di);
476         seq_printf(seq, " RBP\t: %016lx\n", regs->bp);
477         seq_printf(seq, " ESP\t: %016lx\n", regs->sp);
478
479 #ifdef CONFIG_X86_64
480         seq_printf(seq, " R08\t: %016lx\n", regs->r8);
481         seq_printf(seq, " R09\t: %016lx\n", regs->r9);
482         seq_printf(seq, " R10\t: %016lx\n", regs->r10);
483         seq_printf(seq, " R11\t: %016lx\n", regs->r11);
484         seq_printf(seq, " R12\t: %016lx\n", regs->r12);
485         seq_printf(seq, " R13\t: %016lx\n", regs->r13);
486         seq_printf(seq, " R14\t: %016lx\n", regs->r14);
487         seq_printf(seq, " R15\t: %016lx\n", regs->r15);
488 #endif
489
490         asm("movl %%cs,%0" : "=r" (seg));
491         seq_printf(seq, " CS\t:             %04x\n", seg);
492         asm("movl %%ds,%0" : "=r" (seg));
493         seq_printf(seq, " DS\t:             %04x\n", seg);
494         seq_printf(seq, " SS\t:             %04lx\n", regs->ss & 0xffff);
495         asm("movl %%es,%0" : "=r" (seg));
496         seq_printf(seq, " ES\t:             %04x\n", seg);
497         asm("movl %%fs,%0" : "=r" (seg));
498         seq_printf(seq, " FS\t:             %04x\n", seg);
499         asm("movl %%gs,%0" : "=r" (seg));
500         seq_printf(seq, " GS\t:             %04x\n", seg);
501
502         seq_printf(seq, " EFLAGS\t: %016lx\n", regs->flags);
503
504         seq_printf(seq, " EIP\t: %016lx\n", regs->ip);
505 }
506
507 static void print_cr(void *arg)
508 {
509         struct seq_file *seq = arg;
510
511         seq_printf(seq, " cr0\t: %016lx\n", read_cr0());
512         seq_printf(seq, " cr2\t: %016lx\n", read_cr2());
513         seq_printf(seq, " cr3\t: %016lx\n", read_cr3());
514         seq_printf(seq, " cr4\t: %016lx\n", read_cr4_safe());
515 #ifdef CONFIG_X86_64
516         seq_printf(seq, " cr8\t: %016lx\n", read_cr8());
517 #endif
518 }
519
520 static void print_desc_ptr(char *str, struct seq_file *seq, struct desc_ptr dt)
521 {
522         seq_printf(seq, " %s\t: %016llx\n", str, (u64)(dt.address | dt.size));
523 }
524
525 static void print_dt(void *seq)
526 {
527         struct desc_ptr dt;
528         unsigned long ldt;
529
530         /* IDT */
531         store_idt((struct desc_ptr *)&dt);
532         print_desc_ptr("IDT", seq, dt);
533
534         /* GDT */
535         store_gdt((struct desc_ptr *)&dt);
536         print_desc_ptr("GDT", seq, dt);
537
538         /* LDT */
539         store_ldt(ldt);
540         seq_printf(seq, " LDT\t: %016lx\n", ldt);
541
542         /* TR */
543         store_tr(ldt);
544         seq_printf(seq, " TR\t: %016lx\n", ldt);
545 }
546
547 static void print_dr(void *arg)
548 {
549         struct seq_file *seq = arg;
550         unsigned long dr;
551         int i;
552
553         for (i = 0; i < 8; i++) {
554                 /* Ignore db4, db5 */
555                 if ((i == 4) || (i == 5))
556                         continue;
557                 get_debugreg(dr, i);
558                 seq_printf(seq, " dr%d\t: %016lx\n", i, dr);
559         }
560
561         seq_printf(seq, "\n MSR\t:\n");
562 }
563
564 static void print_apic(void *arg)
565 {
566         struct seq_file *seq = arg;
567
568 #ifdef CONFIG_X86_LOCAL_APIC
569         seq_printf(seq, " LAPIC\t:\n");
570         seq_printf(seq, " ID\t\t: %08x\n",  apic_read(APIC_ID) >> 24);
571         seq_printf(seq, " LVR\t\t: %08x\n",  apic_read(APIC_LVR));
572         seq_printf(seq, " TASKPRI\t: %08x\n",  apic_read(APIC_TASKPRI));
573         seq_printf(seq, " ARBPRI\t\t: %08x\n",  apic_read(APIC_ARBPRI));
574         seq_printf(seq, " PROCPRI\t: %08x\n",  apic_read(APIC_PROCPRI));
575         seq_printf(seq, " LDR\t\t: %08x\n",  apic_read(APIC_LDR));
576         seq_printf(seq, " DFR\t\t: %08x\n",  apic_read(APIC_DFR));
577         seq_printf(seq, " SPIV\t\t: %08x\n",  apic_read(APIC_SPIV));
578         seq_printf(seq, " ISR\t\t: %08x\n",  apic_read(APIC_ISR));
579         seq_printf(seq, " ESR\t\t: %08x\n",  apic_read(APIC_ESR));
580         seq_printf(seq, " ICR\t\t: %08x\n",  apic_read(APIC_ICR));
581         seq_printf(seq, " ICR2\t\t: %08x\n",  apic_read(APIC_ICR2));
582         seq_printf(seq, " LVTT\t\t: %08x\n",  apic_read(APIC_LVTT));
583         seq_printf(seq, " LVTTHMR\t: %08x\n",  apic_read(APIC_LVTTHMR));
584         seq_printf(seq, " LVTPC\t\t: %08x\n",  apic_read(APIC_LVTPC));
585         seq_printf(seq, " LVT0\t\t: %08x\n",  apic_read(APIC_LVT0));
586         seq_printf(seq, " LVT1\t\t: %08x\n",  apic_read(APIC_LVT1));
587         seq_printf(seq, " LVTERR\t\t: %08x\n",  apic_read(APIC_LVTERR));
588         seq_printf(seq, " TMICT\t\t: %08x\n",  apic_read(APIC_TMICT));
589         seq_printf(seq, " TMCCT\t\t: %08x\n",  apic_read(APIC_TMCCT));
590         seq_printf(seq, " TDCR\t\t: %08x\n",  apic_read(APIC_TDCR));
591 #endif /* CONFIG_X86_LOCAL_APIC */
592
593         seq_printf(seq, "\n MSR\t:\n");
594 }
595
596 static int cpu_seq_show(struct seq_file *seq, void *v)
597 {
598         struct cpu_private *priv = seq->private;
599
600         if (priv == NULL)
601                 return -EINVAL;
602
603         switch (cpu_base[priv->type].flag) {
604         case CPU_TSS:
605                 smp_call_function_single(priv->cpu, print_tss, seq, 1);
606                 break;
607         case CPU_CR:
608                 smp_call_function_single(priv->cpu, print_cr, seq, 1);
609                 break;
610         case CPU_DT:
611                 smp_call_function_single(priv->cpu, print_dt, seq, 1);
612                 break;
613         case CPU_DEBUG:
614                 if (priv->file == CPU_INDEX_BIT)
615                         smp_call_function_single(priv->cpu, print_dr, seq, 1);
616                 print_msr(seq, priv->cpu, cpu_base[priv->type].flag);
617                 break;
618         case CPU_APIC:
619                 if (priv->file == CPU_INDEX_BIT)
620                         smp_call_function_single(priv->cpu, print_apic, seq, 1);
621                 print_msr(seq, priv->cpu, cpu_base[priv->type].flag);
622                 break;
623
624         default:
625                 print_msr(seq, priv->cpu, cpu_base[priv->type].flag);
626                 break;
627         }
628         seq_printf(seq, "\n");
629
630         return 0;
631 }
632
633 static void *cpu_seq_start(struct seq_file *seq, loff_t *pos)
634 {
635         if (*pos == 0) /* One time is enough ;-) */
636                 return seq;
637
638         return NULL;
639 }
640
641 static void *cpu_seq_next(struct seq_file *seq, void *v, loff_t *pos)
642 {
643         (*pos)++;
644
645         return cpu_seq_start(seq, pos);
646 }
647
648 static void cpu_seq_stop(struct seq_file *seq, void *v)
649 {
650 }
651
652 static const struct seq_operations cpu_seq_ops = {
653         .start          = cpu_seq_start,
654         .next           = cpu_seq_next,
655         .stop           = cpu_seq_stop,
656         .show           = cpu_seq_show,
657 };
658
659 static int cpu_seq_open(struct inode *inode, struct file *file)
660 {
661         struct cpu_private *priv = inode->i_private;
662         struct seq_file *seq;
663         int err;
664
665         err = seq_open(file, &cpu_seq_ops);
666         if (!err) {
667                 seq = file->private_data;
668                 seq->private = priv;
669         }
670
671         return err;
672 }
673
674 static int write_msr(struct cpu_private *priv, u64 val)
675 {
676         u32 low, high;
677
678         high = (val >> 32) & 0xffffffff;
679         low = val & 0xffffffff;
680
681         if (!wrmsr_safe_on_cpu(priv->cpu, priv->reg, low, high))
682                 return 0;
683
684         return -EPERM;
685 }
686
687 static int write_cpu_register(struct cpu_private *priv, const char *buf)
688 {
689         int ret = -EPERM;
690         u64 val;
691
692         ret = strict_strtoull(buf, 0, &val);
693         if (ret < 0)
694                 return ret;
695
696         /* Supporting only MSRs */
697         if (priv->type < CPU_TSS_BIT)
698                 return write_msr(priv, val);
699
700         return ret;
701 }
702
703 static ssize_t cpu_write(struct file *file, const char __user *ubuf,
704                              size_t count, loff_t *off)
705 {
706         struct seq_file *seq = file->private_data;
707         struct cpu_private *priv = seq->private;
708         char buf[19];
709
710         if ((priv == NULL) || (count >= sizeof(buf)))
711                 return -EINVAL;
712
713         if (copy_from_user(&buf, ubuf, count))
714                 return -EFAULT;
715
716         buf[count] = 0;
717
718         if ((cpu_base[priv->type].write) && (cpu_file[priv->file].write))
719                 if (!write_cpu_register(priv, buf))
720                         return count;
721
722         return -EACCES;
723 }
724
725 static const struct file_operations cpu_fops = {
726         .owner          = THIS_MODULE,
727         .open           = cpu_seq_open,
728         .read           = seq_read,
729         .write          = cpu_write,
730         .llseek         = seq_lseek,
731         .release        = seq_release,
732 };
733
734 static int cpu_create_file(unsigned cpu, unsigned type, unsigned reg,
735                            unsigned file, struct dentry *dentry)
736 {
737         struct cpu_private *priv = NULL;
738
739         /* Already intialized */
740         if (file == CPU_INDEX_BIT)
741                 if (per_cpu(cpu_arr[type].init, cpu))
742                         return 0;
743
744         priv = kzalloc(sizeof(*priv), GFP_KERNEL);
745         if (priv == NULL)
746                 return -ENOMEM;
747
748         priv->cpu = cpu;
749         priv->type = type;
750         priv->reg = reg;
751         priv->file = file;
752         mutex_lock(&cpu_debug_lock);
753         per_cpu(priv_arr[type], cpu) = priv;
754         per_cpu(cpu_priv_count, cpu)++;
755         mutex_unlock(&cpu_debug_lock);
756
757         if (file)
758                 debugfs_create_file(cpu_file[file].name, S_IRUGO,
759                                     dentry, (void *)priv, &cpu_fops);
760         else {
761                 debugfs_create_file(cpu_base[type].name, S_IRUGO,
762                                     per_cpu(cpu_arr[type].dentry, cpu),
763                                     (void *)priv, &cpu_fops);
764                 mutex_lock(&cpu_debug_lock);
765                 per_cpu(cpu_arr[type].init, cpu) = 1;
766                 mutex_unlock(&cpu_debug_lock);
767         }
768
769         return 0;
770 }
771
772 static int cpu_init_regfiles(unsigned cpu, unsigned int type, unsigned reg,
773                              struct dentry *dentry)
774 {
775         unsigned file;
776         int err = 0;
777
778         for (file = 0; file <  ARRAY_SIZE(cpu_file); file++) {
779                 err = cpu_create_file(cpu, type, reg, file, dentry);
780                 if (err)
781                         return err;
782         }
783
784         return err;
785 }
786
787 static int cpu_init_msr(unsigned cpu, unsigned type, struct dentry *dentry)
788 {
789         struct dentry *cpu_dentry = NULL;
790         unsigned reg, reg_min, reg_max;
791         int i, range, err = 0;
792         char reg_dir[12];
793         u32 low, high;
794
795         range = get_cpu_range_count(cpu);
796
797         for (i = 0; i < range; i++) {
798                 if (!get_cpu_range(cpu, &reg_min, &reg_max, i,
799                                    cpu_base[type].flag))
800                         continue;
801
802                 for (reg = reg_min; reg <= reg_max; reg++) {
803                         if (rdmsr_safe_on_cpu(cpu, reg, &low, &high))
804                                 continue;
805
806                         sprintf(reg_dir, "0x%x", reg);
807                         cpu_dentry = debugfs_create_dir(reg_dir, dentry);
808                         err = cpu_init_regfiles(cpu, type, reg, cpu_dentry);
809                         if (err)
810                                 return err;
811                 }
812         }
813
814         return err;
815 }
816
817 static int cpu_init_allreg(unsigned cpu, struct dentry *dentry)
818 {
819         struct dentry *cpu_dentry = NULL;
820         unsigned type;
821         int err = 0;
822
823         for (type = 0; type <  ARRAY_SIZE(cpu_base) - 1; type++) {
824                 if (!is_typeflag_valid(cpu, cpu_base[type].flag))
825                         continue;
826                 cpu_dentry = debugfs_create_dir(cpu_base[type].name, dentry);
827                 per_cpu(cpu_arr[type].dentry, cpu) = cpu_dentry;
828
829                 if (type < CPU_TSS_BIT)
830                         err = cpu_init_msr(cpu, type, cpu_dentry);
831                 else
832                         err = cpu_create_file(cpu, type, 0, CPU_INDEX_BIT,
833                                               cpu_dentry);
834                 if (err)
835                         return err;
836         }
837
838         return err;
839 }
840
841 static int cpu_init_cpu(void)
842 {
843         struct dentry *cpu_dentry = NULL;
844         struct cpuinfo_x86 *cpui;
845         char cpu_dir[12];
846         unsigned cpu;
847         int err = 0;
848
849         for (cpu = 0; cpu < nr_cpu_ids; cpu++) {
850                 cpui = &cpu_data(cpu);
851                 if (!cpu_has(cpui, X86_FEATURE_MSR))
852                         continue;
853                 per_cpu(cpu_model, cpu) = ((cpui->x86_vendor << 16) |
854                                            (cpui->x86 << 8) |
855                                            (cpui->x86_model));
856                 per_cpu(cpu_modelflag, cpu) = get_cpu_modelflag(cpu);
857
858                 sprintf(cpu_dir, "cpu%d", cpu);
859                 cpu_dentry = debugfs_create_dir(cpu_dir, cpu_debugfs_dir);
860                 err = cpu_init_allreg(cpu, cpu_dentry);
861
862                 pr_info("cpu%d(%d) debug files %d\n",
863                         cpu, nr_cpu_ids, per_cpu(cpu_priv_count, cpu));
864                 if (per_cpu(cpu_priv_count, cpu) > MAX_CPU_FILES) {
865                         pr_err("Register files count %d exceeds limit %d\n",
866                                 per_cpu(cpu_priv_count, cpu), MAX_CPU_FILES);
867                         per_cpu(cpu_priv_count, cpu) = MAX_CPU_FILES;
868                         err = -ENFILE;
869                 }
870                 if (err)
871                         return err;
872         }
873
874         return err;
875 }
876
877 static int __init cpu_debug_init(void)
878 {
879         cpu_debugfs_dir = debugfs_create_dir("cpu", arch_debugfs_dir);
880
881         return cpu_init_cpu();
882 }
883
884 static void __exit cpu_debug_exit(void)
885 {
886         int i, cpu;
887
888         if (cpu_debugfs_dir)
889                 debugfs_remove_recursive(cpu_debugfs_dir);
890
891         for (cpu = 0; cpu <  nr_cpu_ids; cpu++)
892                 for (i = 0; i < per_cpu(cpu_priv_count, cpu); i++)
893                         kfree(per_cpu(priv_arr[i], cpu));
894 }
895
896 module_init(cpu_debug_init);
897 module_exit(cpu_debug_exit);
898
899 MODULE_AUTHOR("Jaswinder Singh Rajput");
900 MODULE_DESCRIPTION("CPU Debug module");
901 MODULE_LICENSE("GPL");