source: trunk/hal/x86_64/core/hal_init.c @ 365

Last change on this file since 365 was 365, checked in by max@…, 7 years ago

Remove debug function.

File size: 16.2 KB
RevLine 
[29]1/*
2 * hal_init.c - C initialization procedure for x86.
3 *
4 * Copyright (c) 2017 Maxime Villard
5 *
6 * This file is part of ALMOS-MKH.
7 *
8 * ALMOS-MKH is free software; you can redistribute it and/or modify it
9 * under the terms of the GNU General Public License as published by
10 * the Free Software Foundation; version 2.0 of the License.
11 *
12 * ALMOS-MKH is distributed in the hope that it will be useful, but
13 * WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
15 * General Public License for more details.
16 *
17 * You should have received a copy of the GNU General Public License
[234]18 * along with ALMOS-MKH; if not, write to the Free Software Foundation,
[29]19 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
20 */
21
22#include <hal_types.h>
23#include <hal_boot.h>
[32]24#include <hal_multiboot.h>
[29]25#include <hal_segmentation.h>
[45]26#include <hal_acpi.h>
[82]27#include <hal_apic.h>
[308]28#include <hal_kentry.h>
[35]29#include <hal_internal.h>
[166]30#include <hal_register.h>
31
[72]32#include <hal_remote.h>
[99]33#include <hal_irqmask.h>
[29]34
35#include <memcpy.h>
36#include <thread.h>
37#include <string.h>
38#include <process.h>
39#include <printk.h>
40#include <vmm.h>
41#include <core.h>
42#include <cluster.h>
[70]43#include <chdev.h>
[29]44
[70]45#include <boot_info.h>
46
[81]47void kernel_init(boot_info_t *info);
48
[29]49static void gdt_create();
50static void idt_create();
[168]51void cpu_tls_init(size_t lid);
[166]52void cpu_identify();
[237]53void cpu_attach(size_t lid);
[29]54
[44]55size_t mytest __in_kdata = 0;
[32]56
57struct multiboot_info mb_info __in_kdata;
58char mb_loader_name[PAGE_SIZE] __in_kdata;
59uint8_t mb_mmap[PAGE_SIZE] __in_kdata;
[312]60char mb_cmdline[PAGE_SIZE] __in_kdata;
[32]61
[312]62bool_t has_smp __in_kdata = true;
[240]63size_t ncpu __in_kdata = 0;
64static boot_info_t btinfo __in_kdata;
65
[236]66/* x86-specific per-cluster structures */
67uint8_t gdtstore[PAGE_SIZE] __in_kdata;
68uint8_t idtstore[PAGE_SIZE] __in_kdata;
69
70/* x86-specific per-cpu structures */
71typedef struct {
72        bool_t valid;
73        struct tss tss;
74        struct tls tls;
75        uint8_t boot_stack[STKSIZE];
76        uint8_t intr_stack[STKSIZE];
77        uint8_t dbfl_stack[STKSIZE];
78        uint8_t nmfl_stack[STKSIZE];
79} percpu_archdata_t;
80percpu_archdata_t cpudata[CONFIG_MAX_LOCAL_CORES] __in_kdata;
81
[29]82/* -------------------------------------------------------------------------- */
83
[323]84/*
85 * Configure the features of the system depending on the multiboot info.
86 */
87static void multiboot_init()
[312]88{
[32]89        size_t mmap_length = mb_info.mi_mmap_length;
90        uint8_t *mmap_addr = (uint8_t *)&mb_mmap;
91        size_t i;
92
93        if (!(mb_info.mi_flags & MULTIBOOT_INFO_HAS_MMAP))
[46]94                x86_panic("No mmap");
[32]95
96        i = 0;
97        while (i < mmap_length) {
98                struct multiboot_mmap *mm;
99
100                mm = (struct multiboot_mmap *)(mmap_addr + i);
101
102                x86_printf("-> [%Z, %Z] %s\n", mm->mm_base_addr,
103                    mm->mm_base_addr + mm->mm_length,
104                    (mm->mm_type == 1) ? "ram" : "rsv" );
105
106                i += mm->mm_size + 4;
107        }
[312]108
109        if (mb_info.mi_flags & MULTIBOOT_INFO_HAS_CMDLINE) {
110                mb_cmdline[PAGE_SIZE-1] = '\0';
111                if (strstr(mb_cmdline, "--no-smp")) {
112                        has_smp = false;
113                        x86_printf("[+] SMP disabled\n");
114                }
115        }
[32]116}
117
[135]118/* -------------------------------------------------------------------------- */
119
[119]120static size_t init_bootinfo_pages_nr()
121{
122        size_t mmap_length = mb_info.mi_mmap_length;
123        uint8_t *mmap_addr = (uint8_t *)&mb_mmap;
124        paddr_t maxpa, pa;
125        size_t i;
126
127        i = 0;
128        maxpa = 0;
129        while (i < mmap_length) {
130                struct multiboot_mmap *mm;
131
132                mm = (struct multiboot_mmap *)(mmap_addr + i);
133
134                if (mm->mm_type == 1) {
135                        pa = mm->mm_base_addr + mm->mm_length;
136                        if (pa > maxpa)
137                                maxpa = pa;
138                }
139
140                i += mm->mm_size + 4;
141        }
142
143        return (maxpa / PAGE_SIZE);
144}
145
[116]146static size_t init_bootinfo_rsvd(boot_rsvd_t *rsvd)
147{
148        size_t mmap_length = mb_info.mi_mmap_length;
149        uint8_t *mmap_addr = (uint8_t *)&mb_mmap;
150        size_t i, rsvd_nr;
151
[137]152        memset(rsvd, 0, sizeof(boot_rsvd_t) * CONFIG_PPM_MAX_RSVD);
[116]153
154        i = 0, rsvd_nr = 0;
155        while (i < mmap_length) {
156                struct multiboot_mmap *mm;
157
158                mm = (struct multiboot_mmap *)(mmap_addr + i);
159
[119]160                if (mm->mm_type != 1) {
161                        rsvd[rsvd_nr].first_page =
162                            rounddown(mm->mm_base_addr, PAGE_SIZE) / PAGE_SIZE;
163                        rsvd[rsvd_nr].npages =
164                            roundup(mm->mm_length, PAGE_SIZE) / PAGE_SIZE;
165                        rsvd_nr++;
166                        if (rsvd_nr == CONFIG_PPM_MAX_RSVD)
167                                x86_panic("too many memory holes");
168                }
[116]169
170                i += mm->mm_size + 4;
171        }
172
173        return rsvd_nr;
174}
175
[312]176static void init_bootinfo_core(boot_core_t *core, size_t n)
[70]177{
[240]178        size_t i;
[70]179
[240]180        // XXX: not necessarily contiguous
[312]181        for (i = 0; i < n; i++) {
[240]182                memset(&core[i], 0, sizeof(boot_core_t));
183
184                core[i].gid = i;
185                core[i].lid = i;
186                core[i].cxy = 0;
187        }
[70]188}
189
[195]190static void init_bootinfo_ioc(boot_device_t *dev)
191{
192        memset(dev, 0, sizeof(boot_device_t));
193
194        dev->base = 0;
195        dev->type = (DEV_FUNC_IOC << 16) | IMPL_IOC_BDV;
196        dev->channels = 1;
197}
198
[192]199static void init_bootinfo_pic(boot_device_t *dev)
[70]200{
201        memset(dev, 0, sizeof(boot_device_t));
202
[192]203        dev->base = 0;
[252]204        dev->type = (DEV_FUNC_PIC << 16) | IMPL_PIC_I86;
[70]205        dev->channels = 1;
206        dev->param0 = 0;
207        dev->param1 = 0;
208        dev->param2 = 0;
209        dev->param3 = 0;
210
[202]211        dev->irqs = 16;
[192]212
[202]213        /* ATA */
214        dev->irq[IRQ_ATA0].dev_type = (DEV_FUNC_IOC << 16) | IMPL_IOC_BDV;
215        dev->irq[IRQ_ATA0].channel = 0;
216        dev->irq[IRQ_ATA0].is_rx = 0;
217        dev->irq[IRQ_ATA0].valid = 1;
[70]218}
219
[192]220static void init_bootinfo_txt(boot_device_t *dev)
221{
222        memset(dev, 0, sizeof(boot_device_t));
223
224        dev->base = 0;
[254]225        dev->type = (DEV_FUNC_TXT << 16) | IMPL_TXT_RS2;
[255]226        dev->channels = 4;
[192]227        dev->param0 = 0;
228        dev->param1 = 0;
229        dev->param2 = 0;
230        dev->param3 = 0;
231}
232
[70]233static void init_bootinfo(boot_info_t *info)
234{
[116]235        size_t offset;
[114]236
[70]237        memset(info, 0, sizeof(boot_info_t));
238
239        info->signature = 0;
240
241        info->paddr_width = 0;
242        info->x_width = 1;
243        info->y_width = 1;
244        info->x_size = 1;
245        info->y_size = 1;
246        info->io_cxy = 0;
247
[195]248        info->ext_dev_nr = 3;
[70]249        init_bootinfo_txt(&info->ext_dev[0]);
[192]250        init_bootinfo_pic(&info->ext_dev[1]);
[195]251        init_bootinfo_ioc(&info->ext_dev[2]);
[70]252
253        info->cxy = 0;
[312]254        if (has_smp) {
255                info->cores_nr = ncpu;
256        } else {
257                info->cores_nr = 1;
258        }
259        init_bootinfo_core((boot_core_t *)&info->core, info->cores_nr);
[70]260
[137]261        info->rsvd_nr = init_bootinfo_rsvd((boot_rsvd_t *)&info->rsvd);
[70]262
[135]263        /* TODO: dev_mmc */
264        /* TODO: dev_dma */
265
[116]266        offset = hal_gpt_bootstrap_uniformize();
267        info->pages_offset = offset / PAGE_SIZE;
[119]268        info->pages_nr = init_bootinfo_pages_nr();
[70]269}
270
[166]271/* -------------------------------------------------------------------------- */
272
[236]273static uint32_t cpuN_booted __in_kdata;
274
275void start_secondary_cpus()
276{
277        pt_entry_t flags = PG_V | PG_KW;
278        extern vaddr_t cpuN_boot_trampoline;
279        extern vaddr_t cpuN_boot_trampoline_end;
280        extern paddr_t smp_L4pa;
281        extern vaddr_t smp_stkva;
282        extern paddr_t L4paddr;
283        size_t i, sz;
284
285        smp_L4pa = L4paddr;
286
287        /* map the SMP trampoline (identity) */
288        vaddr_t trampva = (vaddr_t)SMP_TRAMPOLINE_PA;
289        hal_gpt_maptree_area(trampva, trampva + PAGE_SIZE);
290        hal_gpt_enter(trampva, SMP_TRAMPOLINE_PA, flags);
291
292        /* copy it */
293        sz = (size_t)&cpuN_boot_trampoline_end - (size_t)&cpuN_boot_trampoline;
294        memcpy((void *)trampva, (void *)&cpuN_boot_trampoline, sz);
295
296        for (i = 0; i < CONFIG_MAX_LOCAL_CORES; i++) {
297                if (i == 0 || !cpudata[i].valid) {
298                        continue;
299                }
300
[283]301                smp_stkva = ((vaddr_t)&cpudata[i].boot_stack + STKSIZE) & ~0xF;
[236]302
303                cpuN_booted = 0;
304                boot_cpuN(i, SMP_TRAMPOLINE_PA);
305                while (!hal_atomic_cas(&cpuN_booted, 1, 0)) {
[310]306                        pause();
[236]307                }
308        }
309
310        // XXX: unmap the trampoline
311}
312
313void init_x86_64_cpuN()
314{
[240]315        lid_t lid;
[237]316
[240]317        cli();
318
319        lid = hal_lapic_gid();
320
[237]321        cpu_attach(lid);
322        x86_printf("[cpu%z] cpu_attach called\n", (uint64_t)lid);
323
324        cpu_tls_init(lid);
325        x86_printf("[cpu%z] cput_tls_init called\n", (uint64_t)lid);
326
327        cpu_lapic_init();
328        x86_printf("[cpu%z] cpu_lapic_init called\n", (uint64_t)lid);
329
[236]330        cpuN_booted = 1;
[237]331
332        if (lid == 1) {
333                hal_ioapic_disable_irq(IRQ_KEYBOARD);
334                hal_ioapic_bind_irq(IRQ_KEYBOARD, IOAPIC_KEYBOARD_VECTOR, 1);
335                hal_ioapic_enable_irq(IRQ_KEYBOARD);
336        }
337
[240]338        kernel_init(&btinfo);
339
340        reg_t dummy;
341        hal_enable_irq(&dummy);
342
[236]343        while (1);
344}
345
346/* -------------------------------------------------------------------------- */
347
[199]348static void apic_map()
349{
350        extern vaddr_t lapic_va, ioapic_va;
351        extern paddr_t lapic_pa, ioapic_pa;
352
353        lapic_va = hal_gpt_bootstrap_valloc(1); // XXX: should be shared
354        hal_gpt_enter(lapic_va, lapic_pa, PG_V|PG_KW|PG_NX|PG_N);
355
356        ioapic_va = hal_gpt_bootstrap_valloc(1); // XXX: should be shared
357        hal_gpt_enter(ioapic_va, ioapic_pa, PG_V|PG_KW|PG_NX|PG_N);
358}
359
[29]360void init_x86_64(paddr_t firstpa)
361{
[240]362        cli();
[70]363
[154]364        /* Initialize the serial port */
365        hal_com_init_early();
366
[29]367        x86_printf("[+] init_x86_64 called\n");
368
369        /* Create the global structures */
370        gdt_create();
371        idt_create();
372
[166]373        /* Identify the features of the cpu */
374        cpu_identify();
375
[29]376        /* Attach cpu0 */
[162]377        cpu_attach(0);
[29]378        x86_printf("[+] cpu_attach called\n");
379
[47]380        x86_printf("[+] bootloader: '%s'\n", mb_loader_name);
[32]381
[323]382        multiboot_init();
383        x86_printf("[+] multiboot_init called\n");
[32]384
[35]385        hal_gpt_init(firstpa);
386        x86_printf("[+] hal_gpt_init called\n");
[29]387
[35]388        hal_acpi_init();
389        x86_printf("[+] hal_acpi_init called\n");
390
[45]391        hal_gpt_bootstrap_reset();
392        x86_printf("[+] hal_gpt_bootstrap_reset called\n");
393
[199]394        apic_map();
395        x86_printf("[+] apic_map called\n");
396
[82]397        hal_apic_init();
[237]398        cpu_lapic_init();
[82]399        x86_printf("[+] hal_apic_init called\n");
[45]400
[168]401        cpu_tls_init(0);
402        x86_printf("[+] cput_tls_init called\n");
[46]403
[224]404        mytest = 0;
[44]405        x86_printf("-> mytest = %z\n", mytest);
[94]406        void *hoho = &init_x86_64;
[74]407        xptr_t myptr = XPTR(0, &mytest);
[35]408
[94]409        hal_remote_spt(myptr, hoho);
410        x86_printf("-> mytest = %Z\n", hal_remote_lpt(myptr));
411
[99]412        init_bootinfo(&btinfo);
[94]413
[312]414        if (has_smp) {
415                start_secondary_cpus();
416        }
[236]417
[276]418        kernel_init(&btinfo);
419
420        x86_printf("[+] kernel_init called\n");
421
[274]422        reg_t dummy;
423        hal_enable_irq(&dummy);
424
425        while (1);
426
[192]427/*
428        void *ptr;
[70]429
[192]430        khm_t *khm = &LOCAL_CLUSTER->khm;
431        ptr = khm_alloc(khm, 10);
432        memset(ptr, 0, 10);
433        khm_free(ptr);
434
435
436        kcm_t *kcm = &LOCAL_CLUSTER->kcm;
437        ptr = kcm_alloc(kcm);
438        memset(ptr, 0, 1);
439        kcm_free(ptr);
440
441        ptr = ppm_alloc_pages(1);
442        ppm_free_pages(ptr);
443*/
[29]444}
445
446/* -------------------------------------------------------------------------- */
447
[235]448void cpu_activate(uint32_t gid)
449{
450        cpudata[gid].valid = true;
451}
452
[323]453static void setregion(struct region_descriptor *rd, void *base, uint16_t limit)
[29]454{
455        rd->rd_limit = limit;
456        rd->rd_base = (uint64_t)base;
457}
458
459/* -------------------------------------------------------------------------- */
460
[323]461static void gdt_set_memseg(struct gdt_memseg *sd, void *base, size_t limit,
[308]462        int type, int dpl, int gran, bool_t is64)
[29]463{
464        sd->sd_lolimit = (unsigned)limit;
465        sd->sd_lobase = (unsigned long)base;
466        sd->sd_type = type;
467        sd->sd_dpl = dpl;
468        sd->sd_p = 1;
469        sd->sd_hilimit = (unsigned)limit >> 16;
470        sd->sd_avl = 0;
471        sd->sd_long = is64;
[308]472        sd->sd_def32 = !is64;
[29]473        sd->sd_gran = gran;
474        sd->sd_hibase = (unsigned long)base >> 24;
475}
476
[323]477static void gdt_set_sysseg(struct gdt_sysseg *sd, void *base, size_t limit,
[29]478        int type, int dpl, int gran)
479{
480        memset(sd, 0, sizeof *sd);
481        sd->sd_lolimit = (unsigned)limit;
482        sd->sd_lobase = (uint64_t)base;
483        sd->sd_type = type;
484        sd->sd_dpl = dpl;
485        sd->sd_p = 1;
486        sd->sd_hilimit = (unsigned)limit >> 16;
487        sd->sd_gran = gran;
488        sd->sd_hibase = (uint64_t)base >> 24;
489}
490
491static void gdt_create()
492{
493        memset(&gdtstore, 0, PAGE_SIZE);
494
495        /* Flat segments */
496        gdt_set_memseg(GDT_ADDR_MEM(gdtstore, GDT_KCODE_SEL), 0,
[308]497            0xfffff, SDT_MEMERA, SEL_KPL, 1, true);
[29]498        gdt_set_memseg(GDT_ADDR_MEM(gdtstore, GDT_KDATA_SEL), 0,
[308]499            0xfffff, SDT_MEMRWA, SEL_KPL, 1, true);
500        gdt_set_memseg(GDT_ADDR_MEM(gdtstore, GDT_UCODE32_SEL), 0,
501            0xfffff, SDT_MEMERA, SEL_UPL, 1, false);
[29]502        gdt_set_memseg(GDT_ADDR_MEM(gdtstore, GDT_UCODE_SEL), 0,
[308]503            0xfffff, SDT_MEMERA, SEL_UPL, 1, true);
[29]504        gdt_set_memseg(GDT_ADDR_MEM(gdtstore, GDT_UDATA_SEL), 0,
[308]505            0xfffff, SDT_MEMRWA, SEL_UPL, 1, true);
[29]506}
507
508void cpu_load_gdt()
509{
510        struct region_descriptor region;
511        setregion(&region, &gdtstore, PAGE_SIZE - 1);
512        lgdt(&region);
513}
514
515/* -------------------------------------------------------------------------- */
516
[203]517struct {
518        bool_t busy[256];
519} idt_bitmap __in_kdata;
520
521int idt_slot_alloc()
522{
523        size_t i;
524
525        for (i = 0; i < 256; i++) {
526                if (!idt_bitmap.busy[i])
527                        break;
528        }
529        if (i == 256) {
530                return -1;
531        }
532
533        idt_bitmap.busy[i] = true;
534        return (int)i;
535}
536
537void idt_slot_free(int slot)
538{
539        idt_bitmap.busy[slot] = false;
540}
541
[323]542static void idt_set_seg(struct idt_seg *seg, void *func, int ist, int type,
543    int dpl, int sel)
[29]544{
545        seg->gd_looffset = (uint64_t)func & 0xffff;
546        seg->gd_selector = sel;
547        seg->gd_ist = ist;
548        seg->gd_type = type;
549        seg->gd_dpl = dpl;
550        seg->gd_p = 1;
551        seg->gd_hioffset = (uint64_t)func >> 16;
552        seg->gd_zero = 0;
553        seg->gd_xx1 = 0;
554        seg->gd_xx2 = 0;
555        seg->gd_xx3 = 0;
556}
557
558static void idt_create()
559{
[80]560        extern uint64_t x86_traps[], x86_intrs[], x86_rsvd;
[29]561        struct idt_seg *idt;
562        size_t i;
[292]563        int ist;
[29]564
[203]565        memset(&idt_bitmap, 0, sizeof(idt_bitmap));
[29]566        idt = (struct idt_seg *)&idtstore;
[45]567
[80]568        /* First, put a dead entry */
569        for (i = 0; i < NIDT; i++) {
570                idt_set_seg(&idt[i], (void *)&x86_rsvd, 0,
571                    SDT_SYS386IGT, SEL_KPL, GDT_FIXED_SEL(GDT_KCODE_SEL, SEL_KPL));
572        }
573
[45]574        /* General exceptions */
575        for (i = CPUVEC_MIN; i < CPUVEC_MAX; i++) {
[292]576                if (i == 2) { /* NMI */
577                        ist = 3;
578                } else if (i == 8) { /* Double Fault */
579                        ist = 2;
580                } else {
581                        ist = 0;
582                }
[293]583                idt_set_seg(&idt[i], (void *)x86_traps[i - CPUVEC_MIN], ist,
[45]584                    SDT_SYS386IGT, SEL_KPL, GDT_FIXED_SEL(GDT_KCODE_SEL, SEL_KPL));
[203]585                idt_bitmap.busy[i] = true;
[29]586        }
[45]587
[138]588        /* Dynamically configured interrupts */
589        for (i = DYNVEC_MIN; i < DYNVEC_MAX; i++) {
590                idt_set_seg(&idt[i], (void *)x86_intrs[i - DYNVEC_MIN], 0,
[45]591                    SDT_SYS386IGT, SEL_KPL, GDT_FIXED_SEL(GDT_KCODE_SEL, SEL_KPL));
[203]592                idt_bitmap.busy[i] = true;
[45]593        }
[29]594}
595
596void cpu_load_idt()
597{
598        struct region_descriptor region;
599        setregion(&region, &idtstore, PAGE_SIZE - 1);
600        lidt(&region);
601}
602
603/* -------------------------------------------------------------------------- */
604
[164]605int tss_alloc(struct tss *tss, size_t lid)
[29]606{
607        int slot;
608
[164]609        slot = GDT_CPUTSS_SEL + lid;
[29]610
611        gdt_set_sysseg(GDT_ADDR_SYS(gdtstore, slot), tss,
612            sizeof(*tss) - 1, SDT_SYS386TSS, SEL_KPL, 0);
613
614        return GDT_DYNAM_SEL(slot, SEL_KPL);
615}
616
[162]617void cpu_create_tss(size_t lid)
[29]618{
[165]619        percpu_archdata_t *data = &cpudata[lid];
620        struct tss *tss = &data->tss;
[29]621        int sel;
622
623        /* Create the tss */
624        memset(tss, 0, sizeof(*tss));
[162]625
[345]626        tss->tss_rsp0 = ((uint64_t)&data->boot_stack + STKSIZE) & ~0xF;
[283]627        tss->tss_ist[0] = ((uint64_t)&data->intr_stack + STKSIZE) & ~0xF;
628        tss->tss_ist[1] = ((uint64_t)&data->dbfl_stack + STKSIZE) & ~0xF;
629        tss->tss_ist[2] = ((uint64_t)&data->nmfl_stack + STKSIZE) & ~0xF;
[29]630        tss->tss_iobase = IOMAP_INVALOFF << 16;
[164]631        sel = tss_alloc(tss, lid);
[29]632
633        /* Load it */
634        ltr(sel);
635}
636
637/* -------------------------------------------------------------------------- */
638
[168]639void cpu_tls_init(size_t lid)
640{
[308]641        extern uint64_t x86_syscall;
642        extern uint64_t x86_syscall32;
643
[168]644        percpu_archdata_t *data = &cpudata[lid];
645        tls_t *cputls = &data->tls;
646
647        memset(cputls, 0, sizeof(tls_t));
648
649        cputls->tls_self = cputls;
650        cputls->tls_gid = hal_lapic_gid();
651        cputls->tls_lid = lid;
[345]652        cputls->tls_rsp0 = (uint64_t)&data->tss.tss_rsp0;
[240]653        cputls->tls_intr = INTRS_DISABLED;
[168]654
[308]655        /* syscall */
656        wrmsr(MSR_STAR,
657            ((uint64_t)GDT_FIXED_SEL(GDT_KCODE_SEL, SEL_KPL) << 32) |
658            ((uint64_t)GDT_FIXED_SEL(GDT_UCODE32_SEL, SEL_UPL) << 48));
659        wrmsr(MSR_LSTAR, (uint64_t)&x86_syscall);
660        wrmsr(MSR_CSTAR, (uint64_t)&x86_syscall32);
661        wrmsr(MSR_SFMASK, PSL_NT|PSL_T|PSL_I|PSL_C|PSL_D);
662
663        /* TLS */
[168]664        wrmsr(MSR_FSBASE, 0);
665        wrmsr(MSR_GSBASE, (uint64_t)cputls);
666        wrmsr(MSR_KERNELGSBASE, 0);
667}
668
669/* -------------------------------------------------------------------------- */
670
[166]671uint64_t cpu_features[4] __in_kdata;
672
673void cpu_identify()
674{
675        /*
676         * desc[0] = eax
677         * desc[1] = ebx
678         * desc[2] = ecx
679         * desc[3] = edx
680         */
681        uint32_t desc[4];
682        char vendor[13];
683        size_t lvl;
684
685        /*
686         * Get information from the standard cpuid leafs
687         */
688        cpuid(0, 0, (uint32_t *)&desc);
689
690        lvl = (uint64_t)desc[0];
691        x86_printf("-> cpuid standard level: %z\n", lvl);
692
693        memcpy(vendor + 0, &desc[1], sizeof(uint32_t));
694        memcpy(vendor + 8, &desc[2], sizeof(uint32_t));
695        memcpy(vendor + 4, &desc[3], sizeof(uint32_t));
696        vendor[12] = '\0';
697        x86_printf("-> CPU vendor: '%s'\n", vendor);
698
699        if (lvl >= 1) {
700                cpuid(1, 0, (uint32_t *)&desc);
701                cpu_features[0] = desc[3];
702                cpu_features[1] = desc[2];
703        }
704
705        /*
706         * Get information from the extended cpuid leafs
707         */
708        cpuid(0x80000000, 0, desc);
709
710        lvl = (uint64_t)desc[0];
711        x86_printf("-> cpuid extended level: %Z\n", lvl);
712}
713
714/* -------------------------------------------------------------------------- */
715
[162]716void cpu_attach(size_t lid)
[29]717{
[168]718        /* Per-cluster structures */
[29]719        cpu_load_gdt();
720        cpu_load_idt();
[168]721
722        /* Per-cpu structures */
[162]723        cpu_create_tss(lid);
[166]724
725        if (cpu_features[0] & CPUID_PSE) {
726                lcr4(rcr4() | CR4_PSE);
727                tlbflushg();
728        } else {
729                /*
730                 * amd64 supports PSE by default, if it's not here we have a
731                 * problem
732                 */
733                x86_panic("PSE not supported");
734        }
[29]735}
736
Note: See TracBrowser for help on using the repository browser.