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

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

provide pages_nr

File size: 9.8 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_remote.h>
30#include <hal_irqmask.h>
31
32#include <memcpy.h>
33#include <thread.h>
34#include <string.h>
35#include <process.h>
36#include <printk.h>
37#include <vmm.h>
38#include <core.h>
39#include <cluster.h>
40#include <chdev.h>
41
42#include <boot_info.h>
43
44void kernel_init(boot_info_t *info);
45
46static void gdt_create();
47static void idt_create();
48void cpu_attach();
49
50size_t mytest __in_kdata = 0;
51
52struct multiboot_info mb_info __in_kdata;
53char mb_loader_name[PAGE_SIZE] __in_kdata;
54uint8_t mb_mmap[PAGE_SIZE] __in_kdata;
55
56/* -------------------------------------------------------------------------- */
57
58static void
59dump_memmap()
60{
61        size_t mmap_length = mb_info.mi_mmap_length;
62        uint8_t *mmap_addr = (uint8_t *)&mb_mmap;
63        size_t i;
64
65        if (!(mb_info.mi_flags & MULTIBOOT_INFO_HAS_MMAP))
66                x86_panic("No mmap");
67
68        i = 0;
69        while (i < mmap_length) {
70                struct multiboot_mmap *mm;
71
72                mm = (struct multiboot_mmap *)(mmap_addr + i);
73
74                x86_printf("-> [%Z, %Z] %s\n", mm->mm_base_addr,
75                    mm->mm_base_addr + mm->mm_length,
76                    (mm->mm_type == 1) ? "ram" : "rsv" );
77
78                i += mm->mm_size + 4;
79        }
80}
81
82static size_t init_bootinfo_pages_nr()
83{
84        size_t mmap_length = mb_info.mi_mmap_length;
85        uint8_t *mmap_addr = (uint8_t *)&mb_mmap;
86        paddr_t maxpa, pa;
87        size_t i;
88
89        i = 0;
90        maxpa = 0;
91        while (i < mmap_length) {
92                struct multiboot_mmap *mm;
93
94                mm = (struct multiboot_mmap *)(mmap_addr + i);
95
96                if (mm->mm_type == 1) {
97                        pa = mm->mm_base_addr + mm->mm_length;
98                        if (pa > maxpa)
99                                maxpa = pa;
100                }
101
102                i += mm->mm_size + 4;
103        }
104
105        return (maxpa / PAGE_SIZE);
106}
107
108static size_t init_bootinfo_rsvd(boot_rsvd_t *rsvd)
109{
110        size_t mmap_length = mb_info.mi_mmap_length;
111        uint8_t *mmap_addr = (uint8_t *)&mb_mmap;
112        size_t i, rsvd_nr;
113
114        memset(rsvd, 0, sizeof(boot_rsvd_t));
115
116        i = 0, rsvd_nr = 0;
117        while (i < mmap_length) {
118                struct multiboot_mmap *mm;
119
120                mm = (struct multiboot_mmap *)(mmap_addr + i);
121
122                if (mm->mm_type != 1) {
123                        rsvd[rsvd_nr].first_page =
124                            rounddown(mm->mm_base_addr, PAGE_SIZE) / PAGE_SIZE;
125                        rsvd[rsvd_nr].npages =
126                            roundup(mm->mm_length, PAGE_SIZE) / PAGE_SIZE;
127                        rsvd_nr++;
128                        if (rsvd_nr == CONFIG_PPM_MAX_RSVD)
129                                x86_panic("too many memory holes");
130                }
131
132                i += mm->mm_size + 4;
133        }
134
135        return rsvd_nr;
136}
137
138static void init_bootinfo_core(boot_core_t *core)
139{
140        memset(core, 0, sizeof(boot_core_t));
141
142        core->gid = hal_lapic_gid();
143        core->lid = 0;
144        core->cxy = 0;
145}
146
147static void init_bootinfo_txt(boot_device_t *dev)
148{
149        memset(dev, 0, sizeof(boot_device_t));
150
151        dev->base = 0xB8000;
152        dev->type = (DEV_FUNC_TXT << 16) | IMPL_TXT_X86;
153        dev->channels = 1;
154        dev->param0 = 0;
155        dev->param1 = 0;
156        dev->param2 = 0;
157        dev->param3 = 0;
158
159#ifdef NOTYET
160    uint32_t    irqs;    /*! number of input IRQs                    */
161    boot_irq_t  irq[32]; /*! array of input IRQS (PIC and ICU only)  */
162#endif
163}
164
165static void init_bootinfo(boot_info_t *info)
166{
167        size_t offset;
168
169        extern uint64_t __kernel_data_start;
170        extern uint64_t __kernel_end;
171
172        memset(info, 0, sizeof(boot_info_t));
173
174        info->signature = 0;
175
176        info->paddr_width = 0;
177        info->x_width = 1;
178        info->y_width = 1;
179        info->x_size = 1;
180        info->y_size = 1;
181        info->io_cxy = 0;
182
183        info->ext_dev_nr = 1;
184        init_bootinfo_txt(&info->ext_dev[0]);
185
186        info->cxy = 0;
187        info->cores_nr = 1;
188        init_bootinfo_core(&info->core[0]);
189
190        info->rsvd_nr = init_bootinfo_rsvd(&info->rsvd);
191
192        /* dev_ XXX */
193        offset = hal_gpt_bootstrap_uniformize();
194        info->pages_offset = offset / PAGE_SIZE;
195        info->pages_nr = init_bootinfo_pages_nr();
196
197        info->kernel_code_start = (intptr_t)(KERNTEXTOFF - KERNBASE);
198        info->kernel_code_end = (intptr_t)(&__kernel_data_start - KERNBASE) - 1;
199        info->kernel_data_start = (intptr_t)(&__kernel_data_start - KERNBASE);
200        info->kernel_code_end = (intptr_t)(&__kernel_end - KERNBASE) - 1;
201}
202
203void init_x86_64(paddr_t firstpa)
204{
205        boot_info_t btinfo;
206
207        x86_printf("[+] init_x86_64 called\n");
208
209        /* Create the global structures */
210        gdt_create();
211        idt_create();
212
213        /* Attach cpu0 */
214        cpu_attach();
215        x86_printf("[+] cpu_attach called\n");
216
217        x86_printf("[+] bootloader: '%s'\n", mb_loader_name);
218
219        dump_memmap();
220        x86_printf("[+] dump finished\n");
221
222        hal_gpt_init(firstpa);
223        x86_printf("[+] hal_gpt_init called\n");
224
225        hal_acpi_init();
226        x86_printf("[+] hal_acpi_init called\n");
227
228        hal_gpt_bootstrap_reset();
229        x86_printf("[+] hal_gpt_bootstrap_reset called\n");
230
231        hal_apic_init();
232        x86_printf("[+] hal_apic_init called\n");
233
234        hal_tls_init_cpu0();
235        x86_printf("[+] hal_tls_init_cpu0 called\n");
236
237        x86_printf("-> mytest = %z\n", mytest);
238        void *hoho = &init_x86_64;
239        xptr_t myptr = XPTR(0, &mytest);
240
241        hal_remote_spt(myptr, hoho);
242        x86_printf("-> mytest = %Z\n", hal_remote_lpt(myptr));
243
244        init_bootinfo(&btinfo);
245
246        reg_t dummy;
247        hal_enable_irq(&dummy);
248
249        kernel_init(&btinfo);
250
251        x86_printf("[+] kernel_init called\n");
252
253        while (1);
254
255//      void x86_stop();
256//      x86_stop();
257
258        int m = 0;
259        int v = 1 / m;
260
261        char *buf = NULL;
262        *buf = (char)0x01;
263
264        x86_printf("ALIVE!\n");
265
266        while (1);
267}
268
269/* -------------------------------------------------------------------------- */
270
271uint8_t gdtstore[PAGE_SIZE] __in_kdata;
272uint8_t idtstore[PAGE_SIZE] __in_kdata;
273struct tss cpu0_tss __in_kdata;
274uint8_t cpu0_intr_stack[STKSIZE] __in_kdata;
275uint8_t cpu0_dbfl_stack[STKSIZE] __in_kdata;
276uint8_t cpu0_nmfl_stack[STKSIZE] __in_kdata;
277
278static void
279setregion(struct region_descriptor *rd, void *base, uint16_t limit)
280{
281        rd->rd_limit = limit;
282        rd->rd_base = (uint64_t)base;
283}
284
285/* -------------------------------------------------------------------------- */
286
287static void
288gdt_set_memseg(struct gdt_memseg *sd, void *base, size_t limit,
289        int type, int dpl, int gran, int is64)
290{
291        sd->sd_lolimit = (unsigned)limit;
292        sd->sd_lobase = (unsigned long)base;
293        sd->sd_type = type;
294        sd->sd_dpl = dpl;
295        sd->sd_p = 1;
296        sd->sd_hilimit = (unsigned)limit >> 16;
297        sd->sd_avl = 0;
298        sd->sd_long = is64;
299        sd->sd_def32 = 0;
300        sd->sd_gran = gran;
301        sd->sd_hibase = (unsigned long)base >> 24;
302}
303
304static void
305gdt_set_sysseg(struct gdt_sysseg *sd, void *base, size_t limit,
306        int type, int dpl, int gran)
307{
308        memset(sd, 0, sizeof *sd);
309        sd->sd_lolimit = (unsigned)limit;
310        sd->sd_lobase = (uint64_t)base;
311        sd->sd_type = type;
312        sd->sd_dpl = dpl;
313        sd->sd_p = 1;
314        sd->sd_hilimit = (unsigned)limit >> 16;
315        sd->sd_gran = gran;
316        sd->sd_hibase = (uint64_t)base >> 24;
317}
318
319static void gdt_create()
320{
321        memset(&gdtstore, 0, PAGE_SIZE);
322
323        /* Flat segments */
324        gdt_set_memseg(GDT_ADDR_MEM(gdtstore, GDT_KCODE_SEL), 0,
325            0xfffff, SDT_MEMERA, SEL_KPL, 1, 1);
326        gdt_set_memseg(GDT_ADDR_MEM(gdtstore, GDT_KDATA_SEL), 0,
327            0xfffff, SDT_MEMRWA, SEL_KPL, 1, 1);
328        gdt_set_memseg(GDT_ADDR_MEM(gdtstore, GDT_UCODE_SEL), 0,
329            0xfffff, SDT_MEMERA, SEL_UPL, 1, 1);
330        gdt_set_memseg(GDT_ADDR_MEM(gdtstore, GDT_UDATA_SEL), 0,
331            0xfffff, SDT_MEMRWA, SEL_UPL, 1, 1);
332}
333
334void cpu_load_gdt()
335{
336        struct region_descriptor region;
337        setregion(&region, &gdtstore, PAGE_SIZE - 1);
338        lgdt(&region);
339}
340
341/* -------------------------------------------------------------------------- */
342
343static void
344idt_set_seg(struct idt_seg *seg, void *func, int ist, int type, int dpl, int sel)
345{
346        seg->gd_looffset = (uint64_t)func & 0xffff;
347        seg->gd_selector = sel;
348        seg->gd_ist = ist;
349        seg->gd_type = type;
350        seg->gd_dpl = dpl;
351        seg->gd_p = 1;
352        seg->gd_hioffset = (uint64_t)func >> 16;
353        seg->gd_zero = 0;
354        seg->gd_xx1 = 0;
355        seg->gd_xx2 = 0;
356        seg->gd_xx3 = 0;
357}
358
359static void idt_create()
360{
361        extern uint64_t x86_traps[], x86_intrs[], x86_rsvd;
362        struct idt_seg *idt;
363        size_t i;
364
365        idt = (struct idt_seg *)&idtstore;
366
367        /* First, put a dead entry */
368        for (i = 0; i < NIDT; i++) {
369                idt_set_seg(&idt[i], (void *)&x86_rsvd, 0,
370                    SDT_SYS386IGT, SEL_KPL, GDT_FIXED_SEL(GDT_KCODE_SEL, SEL_KPL));
371        }
372
373        /* General exceptions */
374        for (i = CPUVEC_MIN; i < CPUVEC_MAX; i++) {
375                idt_set_seg(&idt[i], (void *)x86_traps[i - CPUVEC_MIN], 0,
376                    SDT_SYS386IGT, SEL_KPL, GDT_FIXED_SEL(GDT_KCODE_SEL, SEL_KPL));
377        }
378
379        /* LAPIC interrupts */
380        for (i = LAPICVEC_MIN; i < LAPICVEC_MAX; i++) {
381                idt_set_seg(&idt[i], (void *)x86_intrs[i - LAPICVEC_MIN], 0,
382                    SDT_SYS386IGT, SEL_KPL, GDT_FIXED_SEL(GDT_KCODE_SEL, SEL_KPL));
383        }
384}
385
386void cpu_load_idt()
387{
388        struct region_descriptor region;
389        setregion(&region, &idtstore, PAGE_SIZE - 1);
390        lidt(&region);
391}
392
393/* -------------------------------------------------------------------------- */
394
395/*
396 * The gdt bitmap must be per-cluster.
397 */
398int tss_alloc(struct tss *tss)
399{
400        int slot;
401
402        /* Once we have proper SMP support, we will change that */
403        slot = GDT_CPU0TSS_SEL;
404
405        gdt_set_sysseg(GDT_ADDR_SYS(gdtstore, slot), tss,
406            sizeof(*tss) - 1, SDT_SYS386TSS, SEL_KPL, 0);
407
408        return GDT_DYNAM_SEL(slot, SEL_KPL);
409}
410
411void cpu_create_tss()
412{
413        struct tss *tss = &cpu0_tss;
414        int sel;
415
416        /* Create the tss */
417        memset(tss, 0, sizeof(*tss));
418        tss->tss_iobase = IOMAP_INVALOFF << 16;
419        tss->tss_ist[0] = (uint64_t)cpu0_intr_stack + STKSIZE;
420        tss->tss_ist[1] = (uint64_t)cpu0_dbfl_stack + STKSIZE;
421        tss->tss_ist[2] = (uint64_t)cpu0_nmfl_stack + STKSIZE;
422        sel = tss_alloc(tss);
423
424        /* Load it */
425        ltr(sel);
426}
427
428/* -------------------------------------------------------------------------- */
429
430void cpu_attach()
431{
432        cpu_load_gdt();
433        cpu_load_idt();
434        cpu_create_tss();
435}
436
Note: See TracBrowser for help on using the repository browser.