Major reorganization in prep for appserver merge
[akaros.git] / kern / arch / i686 / cpuinfo.c
1 /*
2  * Copyright (c) 2009 The Regents of the University of California
3  * Barret Rhoden <brho@cs.berkeley.edu>
4  * See LICENSE for details.
5  */
6
7 #ifdef __SHARC__
8 #pragma nosharc
9 #endif
10
11 #include <arch/arch.h>
12 #include <arch/x86.h>
13 #include <arch/mmu.h>
14 #include <stdio.h>
15 #include <assert.h>
16 #include <ros/memlayout.h>
17 #include <pmap.h>
18 #include <kdebug.h>
19 #include <string.h>
20
21 void print_cpuinfo(void)
22 {
23         uint32_t eax, ebx, ecx, edx;
24         uint32_t model, family;
25         uint64_t msr_val;
26         char vendor_id[13];
27         extern char (SNT RO _start)[];
28
29         asm volatile ("cpuid;"
30                   "movl    %%ebx, (%2);"
31                   "movl    %%edx, 4(%2);"
32                   "movl    %%ecx, 8(%2);"
33                  : "=a"(eax)
34                  : "a"(0), "D"(vendor_id)
35                  : "%ebx", "%ecx", "%edx");
36
37         vendor_id[12] = '\0';
38         cprintf("Vendor ID: %s\n", vendor_id);
39         cprintf("Largest Standard Function Number Supported: %d\n", eax);
40         cpuid(0x80000000, &eax, 0, 0, 0);
41         cprintf("Largest Extended Function Number Supported: 0x%08x\n", eax);
42         cpuid(1, &eax, &ebx, &ecx, &edx);
43         family = ((eax & 0x0FF00000) >> 20) + ((eax & 0x00000F00) >> 8);
44         model = ((eax & 0x000F0000) >> 12) + ((eax & 0x000000F0) >> 4);
45         cprintf("Family: %d\n", family);
46         cprintf("Model: %d\n", model);
47         cprintf("Stepping: %d\n", eax & 0x0000000F);
48         // eventually can fill this out with SDM Vol3B App B info, or
49         // better yet with stepping info.  or cpuid 8000_000{2,3,4}
50         switch ( family << 8 | model ) {
51                 case(0x061a):
52                         cprintf("Processor: Core i7\n");
53                         break;
54                 case(0x060f):
55                         cprintf("Processor: Core 2 Duo or Similar\n");
56                         break;
57                 default:
58                         cprintf("Unknown or non-Intel CPU\n");
59         }
60         if (!(edx & 0x00000020))
61                 panic("MSRs not supported!");
62         if (!(edx & 0x00001000))
63                 panic("MTRRs not supported!");
64         if (!(edx & 0x00002000))
65                 panic("Global Pages not supported!");
66         if (!(edx & 0x00000200))
67                 panic("Local APIC Not Detected!");
68         if (ecx & 0x00200000)
69                 cprintf("x2APIC Detected\n");
70         else
71                 cprintf("x2APIC Not Detected\n");
72         if (ecx & 0x00000060) {
73                 msr_val = read_msr(IA32_FEATURE_CONTROL);
74                 printd("64 Bit Feature Control: 0x%08x\n", msr_val);
75                 if ((msr_val & 0x5) == 0x5)
76                         printk("Hardware virtualization supported\n");
77                 else
78                         printk("Hardware virtualization not supported\n");
79         } else { 
80                 printk("Hardware virtualization not supported\n");
81         }
82         cpuid(0x80000008, &eax, &ebx, &ecx, &edx);
83         cprintf("Physical Address Bits: %d\n", eax & 0x000000FF);
84         cprintf("Cores per Die: %d\n", (ecx & 0x000000FF) + 1);
85     cprintf("This core's Default APIC ID: 0x%08x\n", lapic_get_default_id());
86         msr_val = read_msr(IA32_APIC_BASE);
87         if (msr_val & MSR_APIC_ENABLE)
88                 cprintf("Local APIC Enabled\n");
89         else
90                 cprintf("Local APIC Disabled\n");
91         if (msr_val & 0x00000100)
92                 cprintf("I am the Boot Strap Processor\n");
93         else
94                 cprintf("I am an Application Processor\n");
95         cpuid(0x80000007, &eax, &ebx, &ecx, &edx);
96         if (edx & 0x00000100)
97                 printk("Invariant TSC present\n");
98         else
99                 printk("Invariant TSC not present\n");
100 }
101
102 void show_mapping(uintptr_t start, size_t size)
103 {
104         pde_t LCKD(&vpd_lock) *CT(PTSIZE) pgdir =
105             (pde_t LCKD(&vpd_lock) *CT(PTSIZE))vpd;
106         pte_t *pte;
107         pte_t LCKD(&vpd_lock) *pde;
108         page_t *page;
109         uintptr_t i;
110
111         cprintf("   Virtual    Physical  Ps Dr Ac CD WT U W\n");
112         cprintf("------------------------------------------\n");
113         for(i = 0; i < size; i += PGSIZE, start += PGSIZE) {
114                 page = page_lookup(pgdir, (void*SNT)start, &pte);
115                 cprintf("%08p  ", start);
116                 if (page) {
117                         pde = &pgdir[PDX(start)];
118                         // for a jumbo, pde = pte and PTE_PS (better be) = 1
119                         cprintf("%08p  %1d  %1d  %1d  %1d  %1d  %1d %1d\n", page2pa(page),
120                                (*pte & PTE_PS) >> 7, (*pte & PTE_D) >> 6, (*pte & PTE_A) >> 5,
121                                (*pte & PTE_PCD) >> 4, (*pte & PTE_PWT) >> 3,
122                                (*pte & *pde & PTE_U) >> 2, (*pte & *pde & PTE_W) >> 1);
123                 } else
124                         cprintf("%08p\n", 0);
125         }
126 }
127
128 void backtrace(void)
129 { TRUSTEDBLOCK
130         extern char (SNT RO _start)[];
131         uint32_t *ebp, eip;
132         eipdebuginfo_t debuginfo;
133         char buf[256];
134         int j, i = 1;
135         ebp = (uint32_t*)read_ebp();
136         // this is part of the way back into the call() instruction's bytes
137         // eagle-eyed readers should be able to explain why this is good enough,
138         // and retaddr (just *(ebp + 1) is not)
139         eip = *(ebp + 1) - 1;
140         // jump back a frame (out of backtrace)
141         ebp = (uint32_t*)(*ebp);
142         cprintf("Stack Backtrace:\n");
143         // on each iteration, ebp holds the stack frame and eip an addr in that func
144         while (ebp != 0) {
145                 debuginfo_eip(eip, &debuginfo);
146                 memset(buf, 0, 256);
147                 strncpy(buf, debuginfo.eip_fn_name, MIN(debuginfo.eip_fn_namelen, 256));
148                 buf[MIN(debuginfo.eip_fn_namelen, 255)] = 0;
149                 cprintf("#%02d [<%p>] in %s+%x(%p) from %s:%d\n", i++,  eip, buf, 
150                         debuginfo.eip_fn_addr - (uint32_t)_start, debuginfo.eip_fn_addr, 
151                         debuginfo.eip_file, debuginfo.eip_line);
152                 cprintf("    ebp: %x   Args:", ebp);
153                 for (j = 0; j < MIN(debuginfo.eip_fn_narg, 5); j++)
154                         cprintf(" %08x", *(ebp + 2 + j));
155                 cprintf("\n");
156                 eip = *(ebp + 1) - 1;
157                 ebp = (uint32_t*)(*ebp);
158         }
159 }
160
161 /* Like backtrace, this is probably not the best place for this. */
162 void spinlock_debug(spinlock_t *lock)
163 {
164 #ifdef SPINLOCK_DEBUG
165         eipdebuginfo_t debuginfo;
166         char buf[256];
167         uint32_t eip = (uint32_t)lock->call_site;
168
169         debuginfo_eip(eip, &debuginfo);
170         memset(buf, 0, 256);
171         strncpy(buf, debuginfo.eip_fn_name, MIN(debuginfo.eip_fn_namelen, 256));
172         buf[MIN(debuginfo.eip_fn_namelen, 255)] = 0;
173         printk("Lock %p: last locked at [<%p>] in %s(%p) on core %d\n", lock, eip, buf,
174                debuginfo.eip_fn_addr, lock->calling_core);
175 #endif
176 }
177