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

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

Start adding some code for SMP support

File size: 13.7 KB
Line 
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
18 * along with ALMOS-MKH; if not, write to the Free Software Foundation,
19 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
20 */
21
22#include <hal_types.h>
23#include <hal_boot.h>
24#include <hal_multiboot.h>
25#include <hal_segmentation.h>
26#include <hal_acpi.h>
27#include <hal_apic.h>
28#include <hal_internal.h>
29#include <hal_register.h>
30
31#include <hal_remote.h>
32#include <hal_irqmask.h>
33
34#include <memcpy.h>
35#include <thread.h>
36#include <string.h>
37#include <process.h>
38#include <printk.h>
39#include <vmm.h>
40#include <core.h>
41#include <cluster.h>
42#include <chdev.h>
43
44#include <boot_info.h>
45
46void kernel_init(boot_info_t *info);
47
48static void gdt_create();
49static void idt_create();
50void cpu_tls_init(size_t lid);
51void cpu_identify();
52void cpu_attach();
53
54size_t mytest __in_kdata = 0;
55
56struct multiboot_info mb_info __in_kdata;
57char mb_loader_name[PAGE_SIZE] __in_kdata;
58uint8_t mb_mmap[PAGE_SIZE] __in_kdata;
59
60/* -------------------------------------------------------------------------- */
61
62static void
63dump_memmap()
64{
65        size_t mmap_length = mb_info.mi_mmap_length;
66        uint8_t *mmap_addr = (uint8_t *)&mb_mmap;
67        size_t i;
68
69        if (!(mb_info.mi_flags & MULTIBOOT_INFO_HAS_MMAP))
70                x86_panic("No mmap");
71
72        i = 0;
73        while (i < mmap_length) {
74                struct multiboot_mmap *mm;
75
76                mm = (struct multiboot_mmap *)(mmap_addr + i);
77
78                x86_printf("-> [%Z, %Z] %s\n", mm->mm_base_addr,
79                    mm->mm_base_addr + mm->mm_length,
80                    (mm->mm_type == 1) ? "ram" : "rsv" );
81
82                i += mm->mm_size + 4;
83        }
84}
85
86/* -------------------------------------------------------------------------- */
87
88static size_t init_bootinfo_pages_nr()
89{
90        size_t mmap_length = mb_info.mi_mmap_length;
91        uint8_t *mmap_addr = (uint8_t *)&mb_mmap;
92        paddr_t maxpa, pa;
93        size_t i;
94
95        i = 0;
96        maxpa = 0;
97        while (i < mmap_length) {
98                struct multiboot_mmap *mm;
99
100                mm = (struct multiboot_mmap *)(mmap_addr + i);
101
102                if (mm->mm_type == 1) {
103                        pa = mm->mm_base_addr + mm->mm_length;
104                        if (pa > maxpa)
105                                maxpa = pa;
106                }
107
108                i += mm->mm_size + 4;
109        }
110
111        return (maxpa / PAGE_SIZE);
112}
113
114static size_t init_bootinfo_rsvd(boot_rsvd_t *rsvd)
115{
116        size_t mmap_length = mb_info.mi_mmap_length;
117        uint8_t *mmap_addr = (uint8_t *)&mb_mmap;
118        size_t i, rsvd_nr;
119
120        memset(rsvd, 0, sizeof(boot_rsvd_t) * CONFIG_PPM_MAX_RSVD);
121
122        i = 0, rsvd_nr = 0;
123        while (i < mmap_length) {
124                struct multiboot_mmap *mm;
125
126                mm = (struct multiboot_mmap *)(mmap_addr + i);
127
128                if (mm->mm_type != 1) {
129                        rsvd[rsvd_nr].first_page =
130                            rounddown(mm->mm_base_addr, PAGE_SIZE) / PAGE_SIZE;
131                        rsvd[rsvd_nr].npages =
132                            roundup(mm->mm_length, PAGE_SIZE) / PAGE_SIZE;
133                        rsvd_nr++;
134                        if (rsvd_nr == CONFIG_PPM_MAX_RSVD)
135                                x86_panic("too many memory holes");
136                }
137
138                i += mm->mm_size + 4;
139        }
140
141        return rsvd_nr;
142}
143
144static void init_bootinfo_core(boot_core_t *core)
145{
146        memset(core, 0, sizeof(boot_core_t));
147
148        core->gid = hal_lapic_gid();
149        core->lid = 0;
150        core->cxy = 0;
151}
152
153static void init_bootinfo_ioc(boot_device_t *dev)
154{
155        memset(dev, 0, sizeof(boot_device_t));
156
157        dev->base = 0;
158        dev->type = (DEV_FUNC_IOC << 16) | IMPL_IOC_BDV;
159        dev->channels = 1;
160}
161
162static void init_bootinfo_pic(boot_device_t *dev)
163{
164        memset(dev, 0, sizeof(boot_device_t));
165
166        dev->base = 0;
167        dev->type = (DEV_FUNC_PIC << 16) | IMPL_PIC_SCL;
168        dev->channels = 1;
169        dev->param0 = 0;
170        dev->param1 = 0;
171        dev->param2 = 0;
172        dev->param3 = 0;
173
174        dev->irqs = 16;
175
176        /* COM1 */
177        dev->irq[IRQ_COM1].dev_type = (DEV_FUNC_TXT << 16) | IMPL_TXT_TTY;
178        dev->irq[IRQ_COM1].channel = 0;
179        dev->irq[IRQ_COM1].is_rx = 0;
180        dev->irq[IRQ_COM1].valid = 1;
181
182        /* ATA */
183        dev->irq[IRQ_ATA0].dev_type = (DEV_FUNC_IOC << 16) | IMPL_IOC_BDV;
184        dev->irq[IRQ_ATA0].channel = 0;
185        dev->irq[IRQ_ATA0].is_rx = 0;
186        dev->irq[IRQ_ATA0].valid = 1;
187}
188
189static void init_bootinfo_txt(boot_device_t *dev)
190{
191        memset(dev, 0, sizeof(boot_device_t));
192
193        dev->base = 0;
194        dev->type = (DEV_FUNC_TXT << 16) | IMPL_TXT_TTY;
195        dev->channels = 1;
196        dev->param0 = 0;
197        dev->param1 = 0;
198        dev->param2 = 0;
199        dev->param3 = 0;
200}
201
202static void init_bootinfo(boot_info_t *info)
203{
204        size_t offset;
205
206        extern uint64_t __kernel_data_start;
207        extern uint64_t __kernel_end;
208
209        memset(info, 0, sizeof(boot_info_t));
210
211        info->signature = 0;
212
213        info->paddr_width = 0;
214        info->x_width = 1;
215        info->y_width = 1;
216        info->x_size = 1;
217        info->y_size = 1;
218        info->io_cxy = 0;
219
220        info->ext_dev_nr = 3;
221        init_bootinfo_txt(&info->ext_dev[0]);
222        init_bootinfo_pic(&info->ext_dev[1]);
223        init_bootinfo_ioc(&info->ext_dev[2]);
224
225        info->cxy = 0;
226        info->cores_nr = 1;
227        init_bootinfo_core(&info->core[0]);
228
229        info->rsvd_nr = init_bootinfo_rsvd((boot_rsvd_t *)&info->rsvd);
230
231        /* TODO: dev_icu */
232        /* TODO: dev_mmc */
233        /* TODO: dev_dma */
234
235        offset = hal_gpt_bootstrap_uniformize();
236        info->pages_offset = offset / PAGE_SIZE;
237        info->pages_nr = init_bootinfo_pages_nr();
238
239        info->kernel_code_start = (intptr_t)(KERNTEXTOFF - KERNBASE);
240        info->kernel_code_end = (intptr_t)(&__kernel_data_start - KERNBASE) - 1;
241        info->kernel_data_start = (intptr_t)(&__kernel_data_start - KERNBASE);
242        info->kernel_code_end = (intptr_t)(&__kernel_end - KERNBASE) - 1;
243}
244
245/* -------------------------------------------------------------------------- */
246
247static void apic_map()
248{
249        extern vaddr_t lapic_va, ioapic_va;
250        extern paddr_t lapic_pa, ioapic_pa;
251
252        lapic_va = hal_gpt_bootstrap_valloc(1); // XXX: should be shared
253        hal_gpt_enter(lapic_va, lapic_pa, PG_V|PG_KW|PG_NX|PG_N);
254
255        ioapic_va = hal_gpt_bootstrap_valloc(1); // XXX: should be shared
256        hal_gpt_enter(ioapic_va, ioapic_pa, PG_V|PG_KW|PG_NX|PG_N);
257}
258
259void init_x86_64(paddr_t firstpa)
260{
261        boot_info_t btinfo;
262
263        /* Initialize the serial port */
264        hal_com_init_early();
265
266        x86_printf("[+] init_x86_64 called\n");
267
268        /* Create the global structures */
269        gdt_create();
270        idt_create();
271
272        /* Identify the features of the cpu */
273        cpu_identify();
274
275        /* Attach cpu0 */
276        cpu_attach(0);
277        x86_printf("[+] cpu_attach called\n");
278
279        x86_printf("[+] bootloader: '%s'\n", mb_loader_name);
280
281        dump_memmap();
282        x86_printf("[+] dump finished\n");
283
284        hal_gpt_init(firstpa);
285        x86_printf("[+] hal_gpt_init called\n");
286
287        hal_acpi_init();
288        x86_printf("[+] hal_acpi_init called\n");
289
290        hal_gpt_bootstrap_reset();
291        x86_printf("[+] hal_gpt_bootstrap_reset called\n");
292
293        apic_map();
294        x86_printf("[+] apic_map called\n");
295
296        hal_apic_init();
297        x86_printf("[+] hal_apic_init called\n");
298
299        cpu_tls_init(0);
300        x86_printf("[+] cput_tls_init called\n");
301
302        mytest = 0;
303        x86_printf("-> mytest = %z\n", mytest);
304        void *hoho = &init_x86_64;
305        xptr_t myptr = XPTR(0, &mytest);
306
307        hal_remote_spt(myptr, hoho);
308        x86_printf("-> mytest = %Z\n", hal_remote_lpt(myptr));
309
310        init_bootinfo(&btinfo);
311
312        reg_t dummy;
313        hal_enable_irq(&dummy);
314
315while (1);
316
317        kernel_init(&btinfo);
318
319        x86_printf("[+] kernel_init called\n");
320/*
321        void *ptr;
322
323        khm_t *khm = &LOCAL_CLUSTER->khm;
324        ptr = khm_alloc(khm, 10);
325        memset(ptr, 0, 10);
326        khm_free(ptr);
327
328
329        kcm_t *kcm = &LOCAL_CLUSTER->kcm;
330        ptr = kcm_alloc(kcm);
331        memset(ptr, 0, 1);
332        kcm_free(ptr);
333
334        ptr = ppm_alloc_pages(1);
335        ppm_free_pages(ptr);
336*/
337        while (1);
338
339//      void x86_stop();
340//      x86_stop();
341}
342
343/* -------------------------------------------------------------------------- */
344
345/* x86-specific per-cluster structures */
346uint8_t gdtstore[PAGE_SIZE] __in_kdata;
347uint8_t idtstore[PAGE_SIZE] __in_kdata;
348
349/* x86-specific per-cpu structures */
350typedef struct {
351        bool_t valid;
352        struct tss tss;
353        struct tls tls;
354        uint8_t intr_stack[STKSIZE];
355        uint8_t dbfl_stack[STKSIZE];
356        uint8_t nmfl_stack[STKSIZE];
357} percpu_archdata_t;
358percpu_archdata_t cpudata[CONFIG_MAX_LOCAL_CORES] __in_kdata;
359
360void cpu_activate(uint32_t gid)
361{
362        cpudata[gid].valid = true;
363}
364
365static void
366setregion(struct region_descriptor *rd, void *base, uint16_t limit)
367{
368        rd->rd_limit = limit;
369        rd->rd_base = (uint64_t)base;
370}
371
372/* -------------------------------------------------------------------------- */
373
374static void
375gdt_set_memseg(struct gdt_memseg *sd, void *base, size_t limit,
376        int type, int dpl, int gran, int is64)
377{
378        sd->sd_lolimit = (unsigned)limit;
379        sd->sd_lobase = (unsigned long)base;
380        sd->sd_type = type;
381        sd->sd_dpl = dpl;
382        sd->sd_p = 1;
383        sd->sd_hilimit = (unsigned)limit >> 16;
384        sd->sd_avl = 0;
385        sd->sd_long = is64;
386        sd->sd_def32 = 0;
387        sd->sd_gran = gran;
388        sd->sd_hibase = (unsigned long)base >> 24;
389}
390
391static void
392gdt_set_sysseg(struct gdt_sysseg *sd, void *base, size_t limit,
393        int type, int dpl, int gran)
394{
395        memset(sd, 0, sizeof *sd);
396        sd->sd_lolimit = (unsigned)limit;
397        sd->sd_lobase = (uint64_t)base;
398        sd->sd_type = type;
399        sd->sd_dpl = dpl;
400        sd->sd_p = 1;
401        sd->sd_hilimit = (unsigned)limit >> 16;
402        sd->sd_gran = gran;
403        sd->sd_hibase = (uint64_t)base >> 24;
404}
405
406static void gdt_create()
407{
408        memset(&gdtstore, 0, PAGE_SIZE);
409
410        /* Flat segments */
411        gdt_set_memseg(GDT_ADDR_MEM(gdtstore, GDT_KCODE_SEL), 0,
412            0xfffff, SDT_MEMERA, SEL_KPL, 1, 1);
413        gdt_set_memseg(GDT_ADDR_MEM(gdtstore, GDT_KDATA_SEL), 0,
414            0xfffff, SDT_MEMRWA, SEL_KPL, 1, 1);
415        gdt_set_memseg(GDT_ADDR_MEM(gdtstore, GDT_UCODE_SEL), 0,
416            0xfffff, SDT_MEMERA, SEL_UPL, 1, 1);
417        gdt_set_memseg(GDT_ADDR_MEM(gdtstore, GDT_UDATA_SEL), 0,
418            0xfffff, SDT_MEMRWA, SEL_UPL, 1, 1);
419}
420
421void cpu_load_gdt()
422{
423        struct region_descriptor region;
424        setregion(&region, &gdtstore, PAGE_SIZE - 1);
425        lgdt(&region);
426}
427
428/* -------------------------------------------------------------------------- */
429
430struct {
431        bool_t busy[256];
432} idt_bitmap __in_kdata;
433
434int idt_slot_alloc()
435{
436        size_t i;
437
438        for (i = 0; i < 256; i++) {
439                if (!idt_bitmap.busy[i])
440                        break;
441        }
442        if (i == 256) {
443                return -1;
444        }
445
446        idt_bitmap.busy[i] = true;
447        return (int)i;
448}
449
450void idt_slot_free(int slot)
451{
452        idt_bitmap.busy[slot] = false;
453}
454
455static void
456idt_set_seg(struct idt_seg *seg, void *func, int ist, int type, int dpl, int sel)
457{
458        seg->gd_looffset = (uint64_t)func & 0xffff;
459        seg->gd_selector = sel;
460        seg->gd_ist = ist;
461        seg->gd_type = type;
462        seg->gd_dpl = dpl;
463        seg->gd_p = 1;
464        seg->gd_hioffset = (uint64_t)func >> 16;
465        seg->gd_zero = 0;
466        seg->gd_xx1 = 0;
467        seg->gd_xx2 = 0;
468        seg->gd_xx3 = 0;
469}
470
471static void idt_create()
472{
473        extern uint64_t x86_traps[], x86_intrs[], x86_rsvd;
474        struct idt_seg *idt;
475        size_t i;
476
477        memset(&idt_bitmap, 0, sizeof(idt_bitmap));
478        idt = (struct idt_seg *)&idtstore;
479
480        /* First, put a dead entry */
481        for (i = 0; i < NIDT; i++) {
482                idt_set_seg(&idt[i], (void *)&x86_rsvd, 0,
483                    SDT_SYS386IGT, SEL_KPL, GDT_FIXED_SEL(GDT_KCODE_SEL, SEL_KPL));
484        }
485
486        /* General exceptions */
487        for (i = CPUVEC_MIN; i < CPUVEC_MAX; i++) {
488                idt_set_seg(&idt[i], (void *)x86_traps[i - CPUVEC_MIN], 0,
489                    SDT_SYS386IGT, SEL_KPL, GDT_FIXED_SEL(GDT_KCODE_SEL, SEL_KPL));
490                idt_bitmap.busy[i] = true;
491        }
492
493        /* Dynamically configured interrupts */
494        for (i = DYNVEC_MIN; i < DYNVEC_MAX; i++) {
495                idt_set_seg(&idt[i], (void *)x86_intrs[i - DYNVEC_MIN], 0,
496                    SDT_SYS386IGT, SEL_KPL, GDT_FIXED_SEL(GDT_KCODE_SEL, SEL_KPL));
497                idt_bitmap.busy[i] = true;
498        }
499}
500
501void cpu_load_idt()
502{
503        struct region_descriptor region;
504        setregion(&region, &idtstore, PAGE_SIZE - 1);
505        lidt(&region);
506}
507
508/* -------------------------------------------------------------------------- */
509
510int tss_alloc(struct tss *tss, size_t lid)
511{
512        int slot;
513
514        slot = GDT_CPUTSS_SEL + lid;
515
516        gdt_set_sysseg(GDT_ADDR_SYS(gdtstore, slot), tss,
517            sizeof(*tss) - 1, SDT_SYS386TSS, SEL_KPL, 0);
518
519        return GDT_DYNAM_SEL(slot, SEL_KPL);
520}
521
522void cpu_create_tss(size_t lid)
523{
524        percpu_archdata_t *data = &cpudata[lid];
525        struct tss *tss = &data->tss;
526        int sel;
527
528        /* Create the tss */
529        memset(tss, 0, sizeof(*tss));
530
531        /* tss->tss_rsp0 */
532        tss->tss_ist[0] = (uint64_t)data->intr_stack[lid] + STKSIZE;
533        tss->tss_ist[1] = (uint64_t)data->dbfl_stack[lid] + STKSIZE;
534        tss->tss_ist[2] = (uint64_t)data->nmfl_stack[lid] + STKSIZE;
535        tss->tss_iobase = IOMAP_INVALOFF << 16;
536        sel = tss_alloc(tss, lid);
537
538        /* Load it */
539        ltr(sel);
540}
541
542/* -------------------------------------------------------------------------- */
543
544void cpu_tls_init(size_t lid)
545{
546        percpu_archdata_t *data = &cpudata[lid];
547        tls_t *cputls = &data->tls;
548
549        memset(cputls, 0, sizeof(tls_t));
550
551        cputls->tls_self = cputls;
552        cputls->tls_gid = hal_lapic_gid();
553        cputls->tls_lid = lid;
554
555        wrmsr(MSR_FSBASE, 0);
556        wrmsr(MSR_GSBASE, (uint64_t)cputls);
557        wrmsr(MSR_KERNELGSBASE, 0);
558}
559
560/* -------------------------------------------------------------------------- */
561
562uint64_t cpu_features[4] __in_kdata;
563
564void cpu_identify()
565{
566        /*
567         * desc[0] = eax
568         * desc[1] = ebx
569         * desc[2] = ecx
570         * desc[3] = edx
571         */
572        uint32_t desc[4];
573        char vendor[13];
574        size_t lvl;
575
576        /*
577         * Get information from the standard cpuid leafs
578         */
579        cpuid(0, 0, (uint32_t *)&desc);
580
581        lvl = (uint64_t)desc[0];
582        x86_printf("-> cpuid standard level: %z\n", lvl);
583
584        memcpy(vendor + 0, &desc[1], sizeof(uint32_t));
585        memcpy(vendor + 8, &desc[2], sizeof(uint32_t));
586        memcpy(vendor + 4, &desc[3], sizeof(uint32_t));
587        vendor[12] = '\0';
588        x86_printf("-> CPU vendor: '%s'\n", vendor);
589
590        if (lvl >= 1) {
591                cpuid(1, 0, (uint32_t *)&desc);
592                cpu_features[0] = desc[3];
593                cpu_features[1] = desc[2];
594        }
595
596        /*
597         * Get information from the extended cpuid leafs
598         */
599        cpuid(0x80000000, 0, desc);
600
601        lvl = (uint64_t)desc[0];
602        x86_printf("-> cpuid extended level: %Z\n", lvl);
603}
604
605/* -------------------------------------------------------------------------- */
606
607void cpu_attach(size_t lid)
608{
609        /* Per-cluster structures */
610        cpu_load_gdt();
611        cpu_load_idt();
612
613        /* Per-cpu structures */
614        cpu_create_tss(lid);
615
616        if (cpu_features[0] & CPUID_PSE) {
617                lcr4(rcr4() | CR4_PSE);
618                tlbflushg();
619        } else {
620                /*
621                 * amd64 supports PSE by default, if it's not here we have a
622                 * problem
623                 */
624                x86_panic("PSE not supported");
625        }
626}
627
Note: See TracBrowser for help on using the repository browser.