| /kernel/trunk/arch/amd64/src/mm/page.c |
|---|
| 0,0 → 1,74 |
| /* |
| * Copyright (C) 2001-2004 Jakub Jermar |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * - Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * - Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * - The name of the author may not be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| #include <mm/page.h> |
| #include <mm/frame.h> |
| #include <arch/mm/page.h> |
| #include <arch/interrupt.h> |
| #include <arch/asm.h> |
| #include <config.h> |
| #include <memstr.h> |
| __address bootstrap_dba; |
| void page_arch_init(void) |
| { |
| __address dba; |
| count_t i; |
| if (config.cpu_active == 1) { |
| dba = frame_alloc(FRAME_KA | FRAME_PANIC, 0); |
| memsetb(dba, PAGE_SIZE, 0); |
| bootstrap_dba = dba; |
| /* |
| * PA2KA(identity) mapping for all frames. |
| */ |
| for (i = 0; i < config.memory_size/FRAME_SIZE; i++) { |
| page_mapping_insert(PA2KA(i * PAGE_SIZE), i * PAGE_SIZE, PAGE_CACHEABLE | PAGE_EXEC, KA2PA(dba)); |
| } |
| trap_register(14, page_fault); |
| write_cr3(KA2PA(dba)); |
| } |
| else { |
| /* |
| * Application processors need to create their own view of the |
| * virtual address space. Because of that, each AP copies |
| * already-initialized paging information from the bootstrap |
| * processor and adjusts it to fulfill its needs. |
| */ |
| dba = frame_alloc(FRAME_KA | FRAME_PANIC, 0); |
| memcpy((void *)dba, (void *)bootstrap_dba , PAGE_SIZE); |
| write_cr3(KA2PA(dba)); |
| } |
| } |
| /kernel/trunk/arch/amd64/src/mm/tlb.c |
|---|
| 0,0 → 1,0 |
| link ../../../ia32/src/mm/tlb.c |
| Property changes: |
| Added: svn:special |
| +* |
| \ No newline at end of property |
| /kernel/trunk/arch/amd64/src/mm/frame.c |
|---|
| 0,0 → 1,0 |
| link ../../../ia32/src/mm/frame.c |
| Property changes: |
| Added: svn:special |
| +* |
| \ No newline at end of property |
| /kernel/trunk/arch/amd64/src/mm/memory_init.c |
|---|
| 0,0 → 1,0 |
| link ../../../ia32/src/mm/memory_init.c |
| Property changes: |
| Added: svn:special |
| +* |
| \ No newline at end of property |
| /kernel/trunk/arch/amd64/src/amd64.c |
|---|
| 0,0 → 1,111 |
| /* |
| * Copyright (C) 2005 Ondrej Palkovsky |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * - Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * - Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * - The name of the author may not be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| #include <arch.h> |
| #include <arch/types.h> |
| #include <config.h> |
| #include <arch/ega.h> |
| #include <arch/i8042.h> |
| #include <arch/i8254.h> |
| #include <arch/i8259.h> |
| #include <arch/bios/bios.h> |
| #include <arch/mm/memory_init.h> |
| #include <arch/cpu.h> |
| #include <print.h> |
| #include <arch/cpuid.h> |
| #include <genarch/acpi/acpi.h> |
| #include <panic.h> |
| void arch_pre_mm_init(void) |
| { |
| struct cpu_info cpuid_s; |
| cpuid(AMD_CPUID_EXTENDED,&cpuid_s); |
| if (! (cpuid_s.cpuid_edx & (1<<AMD_EXT_NOEXECUTE))) |
| panic("Processor does not support No-execute pages.\n"); |
| cpuid(INTEL_CPUID_STANDARD,&cpuid_s); |
| if (! (cpuid_s.cpuid_edx & (1<<INTEL_FXSAVE))) |
| panic("Processor does not support FXSAVE/FXRESTORE.\n"); |
| if (! (cpuid_s.cpuid_edx & (1<<INTEL_SSE2))) |
| panic("Processor does not support SSE2 instructions.\n"); |
| /* Enable No-execute pages */ |
| set_efer_flag(AMD_NXE_FLAG); |
| /* Enable FPU */ |
| cpu_setup_fpu(); |
| pm_init(); |
| if (config.cpu_active == 1) { |
| bios_init(); |
| i8259_init(); /* PIC */ |
| i8254_init(); /* hard clock */ |
| trap_register(VECTOR_SYSCALL, syscall); |
| #ifdef CONFIG_SMP |
| trap_register(VECTOR_TLB_SHOOTDOWN_IPI, tlb_shootdown_ipi); |
| trap_register(VECTOR_WAKEUP_IPI, wakeup_ipi); |
| #endif /* CONFIG_SMP */ |
| } |
| } |
| void arch_post_mm_init(void) |
| { |
| if (config.cpu_active == 1) { |
| ega_init(); /* video */ |
| } |
| } |
| void arch_pre_smp_init(void) |
| { |
| if (config.cpu_active == 1) { |
| memory_print_map(); |
| #ifdef CONFIG_SMP |
| acpi_init(); |
| #endif /* CONFIG_SMP */ |
| } |
| } |
| void arch_post_smp_init(void) |
| { |
| i8042_init(); /* keyboard controller */ |
| } |
| void calibrate_delay_loop(void) |
| { |
| i8254_calibrate_delay_loop(); |
| i8254_normal_operation(); |
| } |
| /kernel/trunk/arch/amd64/src/smp/ap.S |
|---|
| 0,0 → 1,102 |
| # |
| # Copyright (C) 2001-2004 Jakub Jermar |
| # All rights reserved. |
| # |
| # Redistribution and use in source and binary forms, with or without |
| # modification, are permitted provided that the following conditions |
| # are met: |
| # |
| # - Redistributions of source code must retain the above copyright |
| # notice, this list of conditions and the following disclaimer. |
| # - Redistributions in binary form must reproduce the above copyright |
| # notice, this list of conditions and the following disclaimer in the |
| # documentation and/or other materials provided with the distribution. |
| # - The name of the author may not be used to endorse or promote products |
| # derived from this software without specific prior written permission. |
| # |
| # THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| # IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| # OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| # IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| # INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| # NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| # DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| # THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| # (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| # THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| # |
| # |
| # Init code for application processors. |
| # |
| #include <arch/boot/boot.h> |
| #include <arch/pm.h> |
| #include <arch/cpu.h> |
| #include <arch/cpuid.h> |
| #include <arch/mm/page.h> |
| .section K_TEXT_START_2, "ax" |
| #ifdef CONFIG_SMP |
| .global ap_boot |
| # This piece of code is real-mode and is meant to be alligned at 4K boundary. |
| # The requirement for such an alignment comes from MP Specification's STARTUP IPI |
| # requirements. |
| .align 4096 |
| ap_boot: |
| .code16 |
| cli |
| xorw %ax, %ax |
| movw %ax, %ds |
| lgdt real_bootstrap_gdtr_boot # initialize Global Descriptor Table register |
| movl %cr0, %eax |
| orl $1, %eax |
| movl %eax, %cr0 # switch to protected mode |
| jmpl $gdtselector(KTEXT32_DES), $now_in_prot |
| .code32 |
| now_in_prot: |
| movw $gdtselector(KDATA_DES), %ax |
| movw %ax, %ds |
| movw %ax, %ss |
| # Enable 64-bit page transaltion entries - CR4.PAE = 1. |
| # Paging is not enabled until after long mode is enabled |
| movl %cr4, %eax |
| btsl $5, %eax |
| movl %eax, %cr4 |
| # Set up NEW paging tables, that are |
| # already moved BOOT_OFFSET up |
| leal ptl_0+BOOT_OFFSET, %eax |
| movl %eax, %cr3 |
| # Enable long mode |
| movl $EFER_MSR_NUM, %ecx # EFER MSR number |
| rdmsr # Read EFER |
| btsl $AMD_LME_FLAG, %eax # Set LME=1 |
| wrmsr # Write EFER |
| # Enable paging to activate long mode (set CR0.PG=1) |
| movl %cr0, %eax |
| btsl $31, %eax |
| movl %eax, %cr0 |
| # At this point we are in compatibility mode |
| jmpl $gdtselector(KTEXT_DES), $start64 |
| .code64 |
| start64: |
| movq (ctx), %rsp |
| call main_ap # never returns |
| #endif /* CONFIG_SMP */ |
| /kernel/trunk/arch/amd64/src/smp/mps.c |
|---|
| 0,0 → 1,0 |
| link ../../../ia32/src/smp/mps.c |
| Property changes: |
| Added: svn:special |
| +* |
| \ No newline at end of property |
| /kernel/trunk/arch/amd64/src/smp/smp.c |
|---|
| 0,0 → 1,0 |
| link ../../../ia32/src/smp/smp.c |
| Property changes: |
| Added: svn:special |
| +* |
| \ No newline at end of property |
| /kernel/trunk/arch/amd64/src/smp/ipi.c |
|---|
| 0,0 → 1,0 |
| link ../../../ia32/src/smp/ipi.c |
| Property changes: |
| Added: svn:special |
| +* |
| \ No newline at end of property |
| /kernel/trunk/arch/amd64/src/smp/apic.c |
|---|
| 0,0 → 1,0 |
| link ../../../ia32/src/smp/apic.c |
| Property changes: |
| Added: svn:special |
| +* |
| \ No newline at end of property |
| /kernel/trunk/arch/amd64/src/asm_utils.S |
|---|
| 0,0 → 1,214 |
| # |
| # Copyright (C) 2005 Ondrej Palkovsky |
| # All rights reserved. |
| # |
| # Redistribution and use in source and binary forms, with or without |
| # modification, are permitted provided that the following conditions |
| # are met: |
| # |
| # - Redistributions of source code must retain the above copyright |
| # notice, this list of conditions and the following disclaimer. |
| # - Redistributions in binary form must reproduce the above copyright |
| # notice, this list of conditions and the following disclaimer in the |
| # documentation and/or other materials provided with the distribution. |
| # - The name of the author may not be used to endorse or promote products |
| # derived from this software without specific prior written permission. |
| # |
| # THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| # IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| # OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| # IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| # INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| # NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| # DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| # THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| # (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| # THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| # |
| # Mask for interrupts 0 - 31 (bits 0 - 31) where 0 means that int has no error word |
| # and 1 means interrupt with error word |
| #define ERROR_WORD_INTERRUPT_LIST 0x00027D00 |
| #include <arch/pm.h> |
| .text |
| .global interrupt_handlers |
| .global panic_printf |
| panic_printf: |
| movq $halt, (%rsp) |
| jmp printf |
| .global memcpy |
| memcpy: |
| jmp _memcpy |
| .global cpuid |
| .global has_cpuid |
| .global rdtsc |
| .global read_efer_flag |
| .global set_efer_flag |
| # THIS IS USERSPACE CODE |
| .global utext |
| utext: |
| 0: |
| int $48 |
| jmp 0b |
| # not reached |
| utext_end: |
| .data |
| .global utext_size |
| utext_size: |
| .long utext_end - utext |
| ## Determine CPUID support |
| # |
| # Return 0 in EAX if CPUID is not support, 1 if supported. |
| # |
| has_cpuid: |
| pushfq # store flags |
| popq %rax # read flags |
| movq %rax,%rdx # copy flags |
| btcl $21,%edx # swap the ID bit |
| pushq %rdx |
| popfq # propagate the change into flags |
| pushfq |
| popq %rdx # read flags |
| andl $(1<<21),%eax # interested only in ID bit |
| andl $(1<<21),%edx |
| xorl %edx,%eax # 0 if not supported, 1 if supported |
| ret |
| cpuid: |
| movq %rbx, %r10 # we have to preserve rbx across function calls |
| movl %edi,%eax # load the command into %eax |
| cpuid |
| movl %eax,0(%rsi) |
| movl %ebx,4(%rsi) |
| movl %ecx,8(%rsi) |
| movl %edx,12(%rsi) |
| movq %r10, %rbx |
| ret |
| rdtsc: |
| xorq %rax,%rax |
| rdtsc |
| ret |
| set_efer_flag: |
| movq $0xc0000080, %rcx |
| rdmsr |
| btsl %edi, %eax |
| wrmsr |
| ret |
| read_efer_flag: |
| movq $0xc0000080, %rcx |
| rdmsr |
| ret |
| # Push all general purpose registers on stack except %rbp, %rsp |
| .macro push_all_gpr |
| pushq %rax |
| pushq %rbx |
| pushq %rcx |
| pushq %rdx |
| pushq %rsi |
| pushq %rdi |
| pushq %r8 |
| pushq %r9 |
| pushq %r10 |
| pushq %r11 |
| pushq %r12 |
| pushq %r13 |
| pushq %r14 |
| pushq %r15 |
| .endm |
| .macro pop_all_gpr |
| popq %r15 |
| popq %r14 |
| popq %r13 |
| popq %r12 |
| popq %r11 |
| popq %r10 |
| popq %r9 |
| popq %r8 |
| popq %rdi |
| popq %rsi |
| popq %rdx |
| popq %rcx |
| popq %rbx |
| popq %rax |
| .endm |
| ## Declare interrupt handlers |
| # |
| # Declare interrupt handlers for n interrupt |
| # vectors starting at vector i. |
| # |
| # The handlers setup data segment registers |
| # and call trap_dispatcher(). |
| # |
| .macro handler i n |
| pushq %rbp |
| movq %rsp,%rbp |
| push_all_gpr |
| movq $(\i),%rdi # %rdi - first parameter |
| movq %rbp, %rsi |
| addq $8, %rsi # %rsi - second parameter - original stack |
| call trap_dispatcher # trap_dispatcher(i, stack) |
| # Test if this is interrupt with error word or not |
| mov $\i,%cl; |
| movl $1,%eax; |
| test $0xe0,%cl; |
| jnz 0f; |
| and $0x1f,%cl; |
| shl %cl,%eax; |
| and $ERROR_WORD_INTERRUPT_LIST,%eax; |
| jz 0f; |
| # Return with error word |
| pop_all_gpr |
| popq %rbp; |
| add $8,%esp; # Skip error word |
| iretq |
| 0: |
| # Return with no error word |
| pop_all_gpr |
| popq %rbp |
| iretq |
| .if (\n-\i)-1 |
| handler "(\i+1)",\n |
| .endif |
| .endm |
| interrupt_handlers: |
| h_start: |
| handler 0 IDT_ITEMS |
| h_end: |
| .data |
| .global interrupt_handler_size |
| interrupt_handler_size: .long (h_end-h_start)/IDT_ITEMS |
| /kernel/trunk/arch/amd64/src/boot/boot.S |
|---|
| 0,0 → 1,195 |
| # |
| # Copyright (C) 2005 Ondrej Palkovsky |
| # All rights reserved. |
| # |
| # Redistribution and use in source and binary forms, with or without |
| # modification, are permitted provided that the following conditions |
| # are met: |
| # |
| # - Redistributions of source code must retain the above copyright |
| # notice, this list of conditions and the following disclaimer. |
| # - Redistributions in binary form must reproduce the above copyright |
| # notice, this list of conditions and the following disclaimer in the |
| # documentation and/or other materials provided with the distribution. |
| # - The name of the author may not be used to endorse or promote products |
| # derived from this software without specific prior written permission. |
| # |
| # THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| # IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| # OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| # IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| # INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| # NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| # DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| # THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| # (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| # THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| # |
| #include <arch/mm/page.h> |
| #include <arch/mm/ptl.h> |
| #include <arch/pm.h> |
| #include <arch/cpu.h> |
| #include <arch/cpuid.h> |
| #include <arch/boot/boot.h> |
| #define START_STACK_64 0xffffffff80007c00 |
| # |
| # This is where we require any SPARTAN-kernel-compatible boot loader |
| # to pass control in real mode. |
| # |
| # Protected mode tables are statically initialised during compile |
| # time. So we can just load the respective table registers and |
| # switch to protected mode. |
| # |
| #define START_STACK (BOOTSTRAP_OFFSET-0x400) |
| .section K_TEXT_START, "ax" |
| .code16 |
| .global kernel_image_start |
| kernel_image_start: |
| cli |
| xorw %ax,%ax |
| movw %ax,%ds |
| movw %ax,%es |
| movw %ax,%ss # initialize stack segment register |
| movl $(START_STACK), %esp # initialize stack pointer |
| call memmap_arch_init |
| movl $0x80000000, %eax |
| cpuid |
| cmp $0x80000000, %eax # any function > 80000000h? |
| jbe no_long_mode |
| movl $(AMD_CPUID_EXTENDED), %eax # Extended function code 80000001 |
| cpuid |
| bt $29, %edx # Test if long mode is supported. |
| jnc no_long_mode |
| # Load gdtr, idtr |
| lgdt real_bootstrap_gdtr_boot |
| movl %cr0,%eax |
| orl $0x1,%eax |
| movl %eax,%cr0 # switch to protected mode |
| jmpl $gdtselector(KTEXT32_DES), $now_in_prot |
| no_long_mode: |
| 1: |
| jmp 1b |
| # Protected 32-bit. We want to reuse the code-seg descriptor, |
| # the Default operand size must not be 1 when entering long mode |
| .code32 |
| now_in_prot: |
| # Set up stack & data descriptors |
| movw $gdtselector(KDATA_DES), %ax |
| movw %ax, %ds |
| movw %ax, %ss |
| movb $0xd1, %al # enable A20 using the keyboard controller |
| outb %al, $0x64 |
| movb $0xdf, %al |
| outb %al, $0x60 |
| # Enable 64-bit page transaltion entries - CR4.PAE = 1. |
| # Paging is not enabled until after long mode is enabled |
| movl %cr4, %eax |
| btsl $5, %eax |
| movl %eax, %cr4 |
| # Set up paging tables |
| leal ptl_0, %eax |
| movl %eax, %cr3 |
| # Enable long mode |
| movl $EFER_MSR_NUM, %ecx # EFER MSR number |
| rdmsr # Read EFER |
| btsl $AMD_LME_FLAG, %eax # Set LME=1 |
| wrmsr # Write EFER |
| # Enable paging to activate long mode (set CR0.PG=1) |
| movl %cr0, %eax |
| btsl $31, %eax |
| movl %eax, %cr0 |
| # At this point we are in compatibility mode |
| jmpl $gdtselector(KTEXT_DES), $start64 |
| .code64 |
| start64: |
| movq $(PA2KA(START_STACK)), %rsp |
| # Copy kernel to higher physical memory |
| movq $BOOTSTRAP_OFFSET, %rsi |
| movq $BOOTSTRAP_OFFSET + BOOT_OFFSET, %rdi |
| movq $_hardcoded_kernel_size, %rcx |
| cld |
| rep movsb |
| call main_bsp # never returns |
| 1: |
| jmp 1b |
| .section K_DATA_START, "aw", @progbits |
| .align 4096 |
| # Identical mapping of first 64MB and the same of -2GB -> 0 |
| .global ptl_2 |
| ptl_2: |
| .quad 0x0 | (PTL_WRITABLE | PTL_PRESENT | PTL_2MB_PAGE) |
| .quad 0x200000 | (PTL_WRITABLE | PTL_PRESENT | PTL_2MB_PAGE) |
| .quad 0x400000 | (PTL_WRITABLE | PTL_PRESENT | PTL_2MB_PAGE) |
| .quad 0x600000 | (PTL_WRITABLE | PTL_PRESENT | PTL_2MB_PAGE) |
| .quad 0x800000 | (PTL_WRITABLE | PTL_PRESENT | PTL_2MB_PAGE) |
| .quad 0xa00000 | (PTL_WRITABLE | PTL_PRESENT | PTL_2MB_PAGE) |
| .quad 0xc00000 | (PTL_WRITABLE | PTL_PRESENT | PTL_2MB_PAGE) |
| .quad 0xe00000 | (PTL_WRITABLE | PTL_PRESENT | PTL_2MB_PAGE) |
| .quad 0x1000000 | (PTL_WRITABLE | PTL_PRESENT | PTL_2MB_PAGE) |
| .quad 0x1200000 | (PTL_WRITABLE | PTL_PRESENT | PTL_2MB_PAGE) |
| .quad 0x1400000 | (PTL_WRITABLE | PTL_PRESENT | PTL_2MB_PAGE) |
| .quad 0x1600000 | (PTL_WRITABLE | PTL_PRESENT | PTL_2MB_PAGE) |
| .quad 0x1800000 | (PTL_WRITABLE | PTL_PRESENT | PTL_2MB_PAGE) |
| .quad 0x1a00000 | (PTL_WRITABLE | PTL_PRESENT | PTL_2MB_PAGE) |
| .quad 0x1c00000 | (PTL_WRITABLE | PTL_PRESENT | PTL_2MB_PAGE) |
| .quad 0x1e00000 | (PTL_WRITABLE | PTL_PRESENT | PTL_2MB_PAGE) |
| .quad 0x2000000 | (PTL_WRITABLE | PTL_PRESENT | PTL_2MB_PAGE) |
| .quad 0x2200000 | (PTL_WRITABLE | PTL_PRESENT | PTL_2MB_PAGE) |
| .quad 0x2400000 | (PTL_WRITABLE | PTL_PRESENT | PTL_2MB_PAGE) |
| .quad 0x2600000 | (PTL_WRITABLE | PTL_PRESENT | PTL_2MB_PAGE) |
| .quad 0x2800000 | (PTL_WRITABLE | PTL_PRESENT | PTL_2MB_PAGE) |
| .quad 0x2a00000 | (PTL_WRITABLE | PTL_PRESENT | PTL_2MB_PAGE) |
| .quad 0x2c00000 | (PTL_WRITABLE | PTL_PRESENT | PTL_2MB_PAGE) |
| .quad 0x2e00000 | (PTL_WRITABLE | PTL_PRESENT | PTL_2MB_PAGE) |
| .quad 0x3000000 | (PTL_WRITABLE | PTL_PRESENT | PTL_2MB_PAGE) |
| .quad 0x3200000 | (PTL_WRITABLE | PTL_PRESENT | PTL_2MB_PAGE) |
| .quad 0x3400000 | (PTL_WRITABLE | PTL_PRESENT | PTL_2MB_PAGE) |
| .quad 0x3600000 | (PTL_WRITABLE | PTL_PRESENT | PTL_2MB_PAGE) |
| .quad 0x3800000 | (PTL_WRITABLE | PTL_PRESENT | PTL_2MB_PAGE) |
| .quad 0x3a00000 | (PTL_WRITABLE | PTL_PRESENT | PTL_2MB_PAGE) |
| .quad 0x3c00000 | (PTL_WRITABLE | PTL_PRESENT | PTL_2MB_PAGE) |
| .quad 0x3e00000 | (PTL_WRITABLE | PTL_PRESENT | PTL_2MB_PAGE) |
| .align 4096 |
| .global ptl_1 |
| ptl_1: |
| .quad ptl_2 + (PTL_WRITABLE | PTL_PRESENT) |
| .fill 509,8,0 |
| .quad ptl_2 + (PTL_WRITABLE | PTL_PRESENT) |
| .fill 1,8,0 |
| .align 4096 |
| .global ptl_0 |
| ptl_0: |
| .quad ptl_1 + (PTL_WRITABLE | PTL_PRESENT) |
| .fill 510,8,0 |
| .quad ptl_1 + (PTL_WRITABLE | PTL_PRESENT) |
| .global real_bootstrap_gdtr_boot |
| real_bootstrap_gdtr_boot: |
| .word gdtselector(GDT_ITEMS) |
| .long KA2PA(gdt)-BOOT_OFFSET |
| /kernel/trunk/arch/amd64/src/boot/memmap.S |
|---|
| 0,0 → 1,0 |
| link ../../../ia32/src/boot/memmap.S |
| Property changes: |
| Added: svn:special |
| +* |
| \ No newline at end of property |
| /kernel/trunk/arch/amd64/src/fmath.c |
|---|
| 0,0 → 1,0 |
| link ../../ia32/src/fmath.c |
| Property changes: |
| Added: svn:special |
| +* |
| \ No newline at end of property |
| /kernel/trunk/arch/amd64/src/bios |
|---|
| 0,0 → 1,0 |
| link ../../ia32/src/bios |
| Property changes: |
| Added: svn:special |
| +* |
| \ No newline at end of property |
| /kernel/trunk/arch/amd64/src/drivers |
|---|
| 0,0 → 1,0 |
| link ../../ia32/src/drivers |
| Property changes: |
| Added: svn:special |
| +* |
| \ No newline at end of property |
| /kernel/trunk/arch/amd64/src/interrupt.c |
|---|
| 0,0 → 1,198 |
| /* |
| * Copyright (C) 2001-2004 Jakub Jermar |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * - Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * - Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * - The name of the author may not be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| #include <arch/interrupt.h> |
| #include <print.h> |
| #include <debug.h> |
| #include <panic.h> |
| #include <arch/i8259.h> |
| #include <func.h> |
| #include <cpu.h> |
| #include <arch/asm.h> |
| #include <mm/tlb.h> |
| #include <arch.h> |
| #include <symtab.h> |
| #include <arch/asm.h> |
| #include <proc/scheduler.h> |
| #include <proc/thread.h> |
| static void messy_stack_trace(__native *stack) |
| { |
| __native *upper_limit = (__native *)(((__native)get_stack_base()) + STACK_SIZE); |
| char *symbol; |
| printf("Stack contents: "); |
| while (stack < upper_limit) { |
| symbol = get_symtab_entry((__address)*stack); |
| if (symbol) |
| printf("%s, ", symbol); |
| stack++; |
| } |
| printf("\n"); |
| } |
| static void print_info_errcode(__u8 n, __native x[]) |
| { |
| char *symbol; |
| if (!(symbol=get_symtab_entry(x[1]))) |
| symbol = ""; |
| printf("-----EXCEPTION(%d) OCCURED----- ( %s )\n",n,__FUNCTION__); |
| printf("%%rip: %Q (%s)\n",x[1],symbol); |
| printf("ERROR_WORD=%Q\n", x[0]); |
| printf("%%rcs=%Q,flags=%Q, %%cr0=%Q\n", x[2], x[3],read_cr0()); |
| printf("%%rax=%Q, %%rbx=%Q, %%rcx=%Q\n",x[-2],x[-3],x[-4]); |
| printf("%%rdx=%Q, %%rsi=%Q, %%rdi=%Q\n",x[-5],x[-6],x[-7]); |
| printf("%%r8 =%Q, %%r9 =%Q, %%r10=%Q\n",x[-8],x[-9],x[-10]); |
| printf("%%r11=%Q, %%r12=%Q, %%r13=%Q\n",x[-11],x[-12],x[-13]); |
| printf("%%r14=%Q, %%r15=%Q, %%rsp=%Q\n",x[-14],x[-15],x); |
| printf("%%rbp=%Q\n",x[-1]); |
| printf("stack: %Q, %Q, %Q\n", x[5], x[6], x[7]); |
| printf(" %Q, %Q, %Q\n", x[8], x[9], x[10]); |
| printf(" %Q, %Q, %Q\n", x[11], x[12], x[13]); |
| printf(" %Q, %Q, %Q\n", x[14], x[15], x[16]); |
| printf(" %Q, %Q, %Q\n", x[17], x[18], x[19]); |
| printf(" %Q, %Q, %Q\n", x[20], x[21], x[22]); |
| printf(" %Q, %Q, %Q\n", x[23], x[24], x[25]); |
| messy_stack_trace(&x[5]); |
| } |
| /* |
| * Interrupt and exception dispatching. |
| */ |
| static iroutine ivt[IVT_ITEMS]; |
| void (* disable_irqs_function)(__u16 irqmask) = NULL; |
| void (* enable_irqs_function)(__u16 irqmask) = NULL; |
| void (* eoi_function)(void) = NULL; |
| iroutine trap_register(__u8 n, iroutine f) |
| { |
| ASSERT(n < IVT_ITEMS); |
| iroutine old; |
| old = ivt[n]; |
| ivt[n] = f; |
| return old; |
| } |
| /* |
| * Called directly from the assembler code. |
| * CPU is interrupts_disable()'d. |
| */ |
| void trap_dispatcher(__u8 n, __native stack[]) |
| { |
| ASSERT(n < IVT_ITEMS); |
| ivt[n](n, stack); |
| } |
| void null_interrupt(__u8 n, __native stack[]) |
| { |
| printf("-----EXCEPTION(%d) OCCURED----- ( %s )\n",n,__FUNCTION__); \ |
| printf("stack: %L, %L, %L, %L\n", stack[0], stack[1], stack[2], stack[3]); |
| panic("unserviced interrupt\n"); |
| } |
| void gp_fault(__u8 n, __native stack[]) |
| { |
| print_info_errcode(n,stack); |
| panic("general protection fault\n"); |
| } |
| void ss_fault(__u8 n, __native stack[]) |
| { |
| print_info_errcode(n,stack); |
| panic("stack fault\n"); |
| } |
| void nm_fault(__u8 n, __native stack[]) |
| { |
| #ifdef CONFIG_FPU_LAZY |
| scheduler_fpu_lazy_request(); |
| #else |
| panic("fpu fault"); |
| #endif |
| } |
| void page_fault(__u8 n, __native stack[]) |
| { |
| print_info_errcode(n,stack); |
| printf("Page fault address: %Q\n", read_cr2()); |
| panic("page fault\n"); |
| } |
| void syscall(__u8 n, __native stack[]) |
| { |
| printf("cpu%d: syscall\n", CPU->id); |
| thread_usleep(1000); |
| } |
| void tlb_shootdown_ipi(__u8 n, __native stack[]) |
| { |
| trap_virtual_eoi(); |
| tlb_shootdown_ipi_recv(); |
| } |
| void wakeup_ipi(__u8 n, __native stack[]) |
| { |
| trap_virtual_eoi(); |
| } |
| void trap_virtual_enable_irqs(__u16 irqmask) |
| { |
| if (enable_irqs_function) |
| enable_irqs_function(irqmask); |
| else |
| panic("no enable_irqs_function\n"); |
| } |
| void trap_virtual_disable_irqs(__u16 irqmask) |
| { |
| if (disable_irqs_function) |
| disable_irqs_function(irqmask); |
| else |
| panic("no disable_irqs_function\n"); |
| } |
| void trap_virtual_eoi(void) |
| { |
| if (eoi_function) |
| eoi_function(); |
| else |
| panic("no eoi_function\n"); |
| } |
| /kernel/trunk/arch/amd64/src/context.S |
|---|
| 0,0 → 1,78 |
| # |
| # Copyright (C) 2001-2004 Jakub Jermar |
| # All rights reserved. |
| # |
| # Redistribution and use in source and binary forms, with or without |
| # modification, are permitted provided that the following conditions |
| # are met: |
| # |
| # - Redistributions of source code must retain the above copyright |
| # notice, this list of conditions and the following disclaimer. |
| # - Redistributions in binary form must reproduce the above copyright |
| # notice, this list of conditions and the following disclaimer in the |
| # documentation and/or other materials provided with the distribution. |
| # - The name of the author may not be used to endorse or promote products |
| # derived from this software without specific prior written permission. |
| # |
| # THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| # IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| # OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| # IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| # INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| # NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| # DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| # THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| # (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| # THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| # |
| .text |
| .global context_save_arch |
| .global context_restore_arch |
| #include <arch/context_offset.h> |
| ## Save current CPU context |
| # |
| # Save CPU context to context_t variable |
| # pointed by the 1st argument. Returns 1 in EAX. |
| # |
| context_save_arch: |
| movq (%rsp), %rdx # the caller's return %eip |
| # In %edi is passed 1st argument |
| movq %rdx, OFFSET_PC(%rdi) |
| movq %rsp, OFFSET_SP(%rdi) |
| movq %rbx, OFFSET_RBX(%rdi) |
| movq %rbp, OFFSET_RBP(%rdi) |
| movq %r12, OFFSET_R12(%rdi) |
| movq %r13, OFFSET_R13(%rdi) |
| movq %r14, OFFSET_R14(%rdi) |
| movq %r15, OFFSET_R15(%rdi) |
| xorq %rax,%rax # context_save returns 1 |
| incq %rax |
| ret |
| ## Restore current CPU context |
| # |
| # Restore CPU context from context_t variable |
| # pointed by the 1st argument. Returns 0 in EAX. |
| # |
| context_restore_arch: |
| movq OFFSET_R15(%rdi), %r15 |
| movq OFFSET_R14(%rdi), %r14 |
| movq OFFSET_R13(%rdi), %r13 |
| movq OFFSET_R12(%rdi), %r12 |
| movq OFFSET_RBP(%rdi), %rbp |
| movq OFFSET_RBX(%rdi), %rbx |
| movq OFFSET_SP(%rdi), %rsp # ctx->sp -> %rsp |
| movq OFFSET_PC(%rdi), %rdx |
| movq %rdx,(%rsp) |
| xorq %rax,%rax # context_restore returns 0 |
| ret |
| /kernel/trunk/arch/amd64/src/userspace.c |
|---|
| 0,0 → 1,64 |
| /* |
| * Copyright (C) 2005 Ondrej Palkovsky |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * - Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * - Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * - The name of the author may not be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| #include <userspace.h> |
| #include <arch/pm.h> |
| #include <arch/types.h> |
| #include <arch.h> |
| #include <proc/thread.h> |
| #include <mm/vm.h> |
| /** Enter userspace |
| * |
| * Change CPU protection level to 3, enter userspace. |
| * |
| */ |
| void userspace(void) |
| { |
| ipl_t ipl; |
| ipl = interrupts_disable(); |
| __asm__ volatile ("" |
| "movq %0, %%rax;" |
| "movq %1, %%rbx;" |
| "movq %2, %%rcx;" |
| "movq %3, %%rdx;" |
| "movq %4, %%rsi;" |
| "pushq %%rax;" |
| "pushq %%rbx;" |
| "pushq %%rcx;" |
| "pushq %%rdx;" |
| "pushq %%rsi;" |
| "iretq;" |
| : : "i" (gdtselector(UDATA_DES) | PL_USER), "i" (USTACK_ADDRESS+THREAD_STACK_SIZE), "r" (ipl), "i" (gdtselector(UTEXT_DES) | PL_USER), "i" (UTEXT_ADDRESS)); |
| /* Unreachable */ |
| for(;;); |
| } |
| /kernel/trunk/arch/amd64/src/pm.c |
|---|
| 0,0 → 1,259 |
| /* |
| * Copyright (C) 2001-2004 Jakub Jermar |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * - Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * - Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * - The name of the author may not be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| #include <arch/pm.h> |
| #include <arch/mm/page.h> |
| #include <arch/types.h> |
| #include <arch/interrupt.h> |
| #include <arch/asm.h> |
| #include <config.h> |
| #include <memstr.h> |
| #include <mm/heap.h> |
| #include <debug.h> |
| /* |
| * There is no segmentation in long mode so we set up flat mode. In this |
| * mode, we use, for each privilege level, two segments spanning the |
| * whole memory. One is for code and one is for data. |
| */ |
| struct descriptor gdt[GDT_ITEMS] = { |
| /* NULL descriptor */ |
| { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, |
| /* KTEXT descriptor */ |
| { .limit_0_15 = 0xffff, |
| .base_0_15 = 0, |
| .base_16_23 = 0, |
| .access = AR_PRESENT | AR_CODE | DPL_KERNEL | AR_READABLE , |
| .limit_16_19 = 0xf, |
| .available = 0, |
| .longmode = 1, |
| .special = 0, |
| .granularity = 1, |
| .base_24_31 = 0 }, |
| /* KDATA descriptor */ |
| { .limit_0_15 = 0xffff, |
| .base_0_15 = 0, |
| .base_16_23 = 0, |
| .access = AR_PRESENT | AR_DATA | AR_WRITABLE | DPL_KERNEL, |
| .limit_16_19 = 0xf, |
| .available = 0, |
| .longmode = 0, |
| .special = 0, |
| .granularity = 1, |
| .base_24_31 = 0 }, |
| /* UTEXT descriptor */ |
| { .limit_0_15 = 0xffff, |
| .base_0_15 = 0, |
| .base_16_23 = 0, |
| .access = AR_PRESENT | AR_CODE | DPL_USER, |
| .limit_16_19 = 0xf, |
| .available = 0, |
| .longmode = 1, |
| .special = 0, |
| .granularity = 1, |
| .base_24_31 = 0 }, |
| /* UDATA descriptor */ |
| { .limit_0_15 = 0xffff, |
| .base_0_15 = 0, |
| .base_16_23 = 0, |
| .access = AR_PRESENT | AR_DATA | AR_WRITABLE | DPL_USER, |
| .limit_16_19 = 0xf, |
| .available = 0, |
| .longmode = 0, |
| .special = 1, |
| .granularity = 1, |
| .base_24_31 = 0 }, |
| /* KTEXT 32-bit protected, for protected mode before long mode */ |
| { .limit_0_15 = 0xffff, |
| .base_0_15 = 0, |
| .base_16_23 = 0, |
| .access = AR_PRESENT | AR_CODE | DPL_KERNEL | AR_READABLE, |
| .limit_16_19 = 0xf, |
| .available = 0, |
| .longmode = 0, |
| .special = 1, |
| .granularity = 1, |
| .base_24_31 = 0 }, |
| /* TSS descriptor - set up will be completed later, |
| * on AMD64 it is 64-bit - 2 items in table */ |
| { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, |
| { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } |
| }; |
| struct idescriptor idt[IDT_ITEMS]; |
| struct ptr_16_64 gdtr = {.limit = sizeof(gdt), .base= (__u64) gdt }; |
| struct ptr_16_64 idtr = {.limit = sizeof(idt), .base= (__u64) idt }; |
| static struct tss tss; |
| struct tss *tss_p = NULL; |
| void gdt_tss_setbase(struct descriptor *d, __address base) |
| { |
| struct tss_descriptor *td = (struct tss_descriptor *) d; |
| td->base_0_15 = base & 0xffff; |
| td->base_16_23 = ((base) >> 16) & 0xff; |
| td->base_24_31 = ((base) >> 24) & 0xff; |
| td->base_32_63 = ((base) >> 32); |
| } |
| void gdt_tss_setlimit(struct descriptor *d, __u32 limit) |
| { |
| struct tss_descriptor *td = (struct tss_descriptor *) d; |
| td->limit_0_15 = limit & 0xffff; |
| td->limit_16_19 = (limit >> 16) & 0xf; |
| } |
| void idt_setoffset(struct idescriptor *d, __address offset) |
| { |
| /* |
| * Offset is a linear address. |
| */ |
| d->offset_0_15 = offset & 0xffff; |
| d->offset_16_31 = offset >> 16 & 0xffff; |
| d->offset_32_63 = offset >> 32; |
| } |
| void tss_initialize(struct tss *t) |
| { |
| memsetb((__address) t, sizeof(struct tss), 0); |
| } |
| /* |
| * This function takes care of proper setup of IDT and IDTR. |
| */ |
| void idt_init(void) |
| { |
| struct idescriptor *d; |
| int i; |
| for (i = 0; i < IDT_ITEMS; i++) { |
| d = &idt[i]; |
| d->unused = 0; |
| d->selector = gdtselector(KTEXT_DES); |
| d->present = 1; |
| d->type = AR_INTERRUPT; /* masking interrupt */ |
| if (i == VECTOR_SYSCALL) { |
| /* |
| * The syscall interrupt gate must be calleable from userland. |
| */ |
| d->dpl |= PL_USER; |
| } |
| idt_setoffset(d, ((__address) interrupt_handlers) + i*interrupt_handler_size); |
| trap_register(i, null_interrupt); |
| } |
| trap_register(13, gp_fault); |
| trap_register( 7, nm_fault); |
| trap_register(12, ss_fault); |
| } |
| /* Clean IOPL(12,13) and NT(14) flags in EFLAGS register */ |
| static void clean_IOPL_NT_flags(void) |
| { |
| asm |
| ( |
| "pushfq;" |
| "pop %%rax;" |
| "and $~(0x7000),%%rax;" |
| "pushq %%rax;" |
| "popfq;" |
| : |
| : |
| :"%rax" |
| ); |
| } |
| /* Clean AM(18) flag in CR0 register */ |
| static void clean_AM_flag(void) |
| { |
| asm |
| ( |
| "mov %%cr0,%%rax;" |
| "and $~(0x40000),%%rax;" |
| "mov %%rax,%%cr0;" |
| : |
| : |
| :"%rax" |
| ); |
| } |
| void pm_init(void) |
| { |
| struct descriptor *gdt_p = (struct descriptor *) gdtr.base; |
| struct tss_descriptor *tss_desc; |
| /* |
| * Each CPU has its private GDT and TSS. |
| * All CPUs share one IDT. |
| */ |
| if (config.cpu_active == 1) { |
| idt_init(); |
| /* |
| * NOTE: bootstrap CPU has statically allocated TSS, because |
| * the heap hasn't been initialized so far. |
| */ |
| tss_p = &tss; |
| } |
| else { |
| tss_p = (struct tss *) malloc(sizeof(struct tss)); |
| if (!tss_p) |
| panic("could not allocate TSS\n"); |
| } |
| tss_initialize(tss_p); |
| tss_desc = (struct tss_descriptor *) (&gdt_p[TSS_DES]); |
| tss_desc->present = 1; |
| tss_desc->type = AR_TSS; |
| tss_desc->dpl = PL_KERNEL; |
| gdt_tss_setbase(&gdt_p[TSS_DES], (__address) tss_p); |
| gdt_tss_setlimit(&gdt_p[TSS_DES], sizeof(struct tss) - 1); |
| __asm__("lgdt %0" : : "m"(gdtr)); |
| __asm__("lidt %0" : : "m"(idtr)); |
| /* |
| * As of this moment, the current CPU has its own GDT pointing |
| * to its own TSS. We just need to load the TR register. |
| */ |
| __asm__("ltr %0" : : "r" ((__u16) gdtselector(TSS_DES))); |
| clean_IOPL_NT_flags(); /* Disable I/O on nonprivileged levels */ |
| clean_AM_flag(); /* Disable alignment check */ |
| } |
| /kernel/trunk/arch/amd64/src/cpu/cpu.c |
|---|
| 0,0 → 1,160 |
| /* |
| * Copyright (C) 2001-2004 Jakub Jermar |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * - Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * - Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * - The name of the author may not be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| #include <arch/cpu.h> |
| #include <arch/cpuid.h> |
| #include <arch/pm.h> |
| #include <arch.h> |
| #include <arch/types.h> |
| #include <print.h> |
| #include <typedefs.h> |
| #include <fpu_context.h> |
| /* |
| * Identification of CPUs. |
| * Contains only non-MP-Specification specific SMP code. |
| */ |
| #define AMD_CPUID_EBX 0x68747541 |
| #define AMD_CPUID_ECX 0x444d4163 |
| #define AMD_CPUID_EDX 0x69746e65 |
| #define INTEL_CPUID_EBX 0x756e6547 |
| #define INTEL_CPUID_ECX 0x6c65746e |
| #define INTEL_CPUID_EDX 0x49656e69 |
| enum vendor { |
| VendorUnknown=0, |
| VendorAMD, |
| VendorIntel |
| }; |
| static char *vendor_str[] = { |
| "Unknown Vendor", |
| "AuthenticAMD", |
| "GenuineIntel" |
| }; |
| /** Setup flags on processor so that we can use the FPU |
| * |
| * cr0.osfxsr = 1 -> we do support fxstor/fxrestor |
| * cr0.em = 0 -> we do not emulate coprocessor |
| * cr0.mp = 1 -> we do want lazy context switch |
| */ |
| void cpu_setup_fpu(void) |
| { |
| __asm__ volatile ( |
| "movq %%cr0, %%rax;" |
| "btsq $1, %%rax;" /* cr0.mp */ |
| "btrq $2, %%rax;" /* cr0.em */ |
| "movq %%rax, %%cr0;" |
| "movq %%cr4, %%rax;" |
| "bts $9, %%rax;" /* cr4.osfxsr */ |
| "movq %%rax, %%cr4;" |
| : |
| : |
| :"%rax" |
| ); |
| } |
| /** Set the TS flag to 1. |
| * |
| * If a thread accesses coprocessor, exception is run, which |
| * does a lazy fpu context switch. |
| * |
| */ |
| void fpu_disable(void) |
| { |
| __asm__ volatile ( |
| "mov %%cr0,%%rax;" |
| "bts $3,%%rax;" |
| "mov %%rax,%%cr0;" |
| : |
| : |
| :"%rax" |
| ); |
| } |
| void fpu_enable(void) |
| { |
| __asm__ volatile ( |
| "mov %%cr0,%%rax;" |
| "btr $3,%%rax;" |
| "mov %%rax,%%cr0;" |
| : |
| : |
| :"%rax" |
| ); |
| } |
| void cpu_arch_init(void) |
| { |
| CPU->arch.tss = tss_p; |
| CPU->fpu_owner=NULL; |
| } |
| void cpu_identify(void) |
| { |
| cpu_info_t info; |
| int i; |
| CPU->arch.vendor = VendorUnknown; |
| if (has_cpuid()) { |
| cpuid(0, &info); |
| /* |
| * Check for AMD processor. |
| */ |
| if (info.cpuid_ebx==AMD_CPUID_EBX && info.cpuid_ecx==AMD_CPUID_ECX && info.cpuid_edx==AMD_CPUID_EDX) { |
| CPU->arch.vendor = VendorAMD; |
| } |
| /* |
| * Check for Intel processor. |
| */ |
| if (info.cpuid_ebx==INTEL_CPUID_EBX && info.cpuid_ecx==INTEL_CPUID_ECX && info.cpuid_edx==INTEL_CPUID_EDX) { |
| CPU->arch.vendor = VendorIntel; |
| } |
| cpuid(1, &info); |
| CPU->arch.family = (info.cpuid_eax>>8)&0xf; |
| CPU->arch.model = (info.cpuid_eax>>4)&0xf; |
| CPU->arch.stepping = (info.cpuid_eax>>0)&0xf; |
| } |
| } |
| void cpu_print_report(cpu_t* m) |
| { |
| printf("cpu%d: (%s family=%d model=%d stepping=%d) %dMHz\n", |
| m->id, vendor_str[m->arch.vendor], m->arch.family, m->arch.model, m->arch.stepping, |
| m->frequency_mhz); |
| } |
| /kernel/trunk/arch/amd64/src/fpu_context.c |
|---|
| 0,0 → 1,65 |
| /* |
| * Copyright (C) 2005 Jakub Vana |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * - Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * - Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * - The name of the author may not be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| * |
| */ |
| #include <fpu_context.h> |
| #include <arch.h> |
| #include <cpu.h> |
| /** Save FPU (mmx, sse) context using fxsave instruction */ |
| void fpu_context_save(fpu_context_t *fctx) |
| { |
| /* Align on 16-byte boundary */ |
| if (((__u64)fctx) & 0xf) |
| fctx = (fpu_context_t *)((((__u64)fctx) | 0xf) + 1); |
| __asm__ volatile ( |
| "fxsave %0" |
| : "=m"(*fctx) |
| ); |
| } |
| /** Restore FPU (mmx,sse) context using fxrstor instruction */ |
| void fpu_context_restore(fpu_context_t *fctx) |
| { |
| /* Align on 16-byte boundary */ |
| if (((__u64)fctx) & 0xf) |
| fctx = (fpu_context_t *)((((__u64)fctx) | 0xf) + 1); |
| __asm__ volatile ( |
| "fxrstor %0" |
| : "=m"(*fctx) |
| ); |
| } |
| void fpu_init(void) |
| { |
| /* TODO: Zero all SSE, MMX etc. registers */ |
| __asm__ volatile ( |
| "fninit;" |
| ); |
| } |
| /kernel/trunk/arch/amd64/src/dummy.s |
|---|
| 0,0 → 1,29 |
| # |
| # Copyright (C) 2005 Jakub Jermar |
| # All rights reserved. |
| # |
| # Redistribution and use in source and binary forms, with or without |
| # modification, are permitted provided that the following conditions |
| # are met: |
| # |
| # - Redistributions of source code must retain the above copyright |
| # notice, this list of conditions and the following disclaimer. |
| # - Redistributions in binary form must reproduce the above copyright |
| # notice, this list of conditions and the following disclaimer in the |
| # documentation and/or other materials provided with the distribution. |
| # - The name of the author may not be used to endorse or promote products |
| # derived from this software without specific prior written permission. |
| # |
| # THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| # IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| # OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| # IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| # INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| # NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| # DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| # THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| # (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| # THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| # |
| .text |
| /kernel/trunk/arch/amd64/src/proc/scheduler.c |
|---|
| 0,0 → 1,38 |
| /* |
| * Copyright (C) 2005 Ondrej Palkovsky |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * - Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * - Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * - The name of the author may not be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| #include <proc/scheduler.h> |
| #include <cpu.h> |
| #include <proc/thread.h> |
| #include <arch.h> |
| #include <arch/context.h> /* SP_DELTA */ |
| void before_thread_runs_arch(void) |
| { |
| CPU->arch.tss->rsp0 = (__address) &THREAD->kstack[THREAD_STACK_SIZE-SP_DELTA]; |
| } |
| /kernel/trunk/arch/amd64/src/delay.S |
|---|
| 0,0 → 1,46 |
| # |
| # Copyright (C) 2001-2004 Jakub Jermar |
| # All rights reserved. |
| # |
| # Redistribution and use in source and binary forms, with or without |
| # modification, are permitted provided that the following conditions |
| # are met: |
| # |
| # - Redistributions of source code must retain the above copyright |
| # notice, this list of conditions and the following disclaimer. |
| # - Redistributions in binary form must reproduce the above copyright |
| # notice, this list of conditions and the following disclaimer in the |
| # documentation and/or other materials provided with the distribution. |
| # - The name of the author may not be used to endorse or promote products |
| # derived from this software without specific prior written permission. |
| # |
| # THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| # IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| # OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| # IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| # INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| # NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| # DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| # THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| # (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| # THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| # |
| # |
| # Micro second delay loop functions. |
| # |
| .text |
| .global asm_delay_loop |
| .global asm_fake_loop |
| asm_delay_loop: |
| 0: dec %rdi |
| jnz 0b |
| ret |
| asm_fake_loop: |
| 0: dec %rdi |
| jz 0b |
| ret |
| /kernel/trunk/arch/amd64/Makefile.inc |
|---|
| 0,0 → 1,106 |
| # |
| # Copyright (C) 2005 Martin Decky |
| # All rights reserved. |
| # |
| # Redistribution and use in source and binary forms, with or without |
| # modification, are permitted provided that the following conditions |
| # are met: |
| # |
| # - Redistributions of source code must retain the above copyright |
| # notice, this list of conditions and the following disclaimer. |
| # - Redistributions in binary form must reproduce the above copyright |
| # notice, this list of conditions and the following disclaimer in the |
| # documentation and/or other materials provided with the distribution. |
| # - The name of the author may not be used to endorse or promote products |
| # derived from this software without specific prior written permission. |
| # |
| # THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| # IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| # OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| # IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| # INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| # NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| # DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| # THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| # (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| # THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| # |
| ## Toolchain configuration |
| # |
| BFD_NAME = elf64-x86-64 |
| BFD_ARCH = i386:x86-64 |
| BFD = binary |
| TARGET = amd64-linux-gnu |
| TOOLCHAIN_DIR = /usr/local/amd64/bin |
| ## Make some default assumptions |
| # |
| ifndef CPU |
| CPU = opteron |
| endif |
| CFLAGS += -fno-unwind-tables -m64 -mcmodel=kernel -mno-red-zone |
| DEFS += -D_CPU=${CPU} |
| ## Accepted CPUs |
| # |
| ifeq ($(CPU),opteron) |
| CFLAGS += -march=opteron |
| DEFS += -DFENCES=p4 |
| endif |
| ## Own configuration directives |
| # |
| CONFIG_ACPI = y |
| ## Accepted configuration directives |
| # |
| ifeq ($(CONFIG_SMP),y) |
| DEFS += -DCONFIG_SMP |
| endif |
| ifeq ($(CONFIG_HT),y) |
| DEFS += -DCONFIG_HT |
| endif |
| ifeq ($(CONFIG_FPU_LAZY),y) |
| DEFS += -DCONFIG_FPU_LAZY |
| endif |
| ARCH_SOURCES = \ |
| arch/$(ARCH)/src/dummy.s \ |
| arch/$(ARCH)/src/fpu_context.c \ |
| arch/$(ARCH)/src/boot/boot.S \ |
| arch/$(ARCH)/src/boot/memmap.S \ |
| arch/$(ARCH)/src/pm.c \ |
| arch/$(ARCH)/src/context.S \ |
| arch/$(ARCH)/src/drivers/ega.c \ |
| arch/$(ARCH)/src/drivers/i8042.c \ |
| arch/$(ARCH)/src/drivers/i8254.c \ |
| arch/$(ARCH)/src/drivers/i8259.c \ |
| arch/$(ARCH)/src/delay.S \ |
| arch/$(ARCH)/src/amd64.c \ |
| arch/$(ARCH)/src/bios/bios.c \ |
| arch/$(ARCH)/src/interrupt.c \ |
| arch/$(ARCH)/src/mm/frame.c \ |
| arch/$(ARCH)/src/mm/page.c \ |
| arch/$(ARCH)/src/mm/tlb.c \ |
| arch/$(ARCH)/src/asm_utils.S \ |
| arch/$(ARCH)/src/fmath.c \ |
| arch/$(ARCH)/src/mm/memory_init.c \ |
| arch/$(ARCH)/src/cpu/cpu.c \ |
| arch/$(ARCH)/src/proc/scheduler.c \ |
| arch/$(ARCH)/src/userspace.c |
| ifeq ($(CONFIG_SMP),y) |
| ARCH_SOURCES += \ |
| arch/$(ARCH)/src/smp/ap.S \ |
| arch/$(ARCH)/src/smp/apic.c \ |
| arch/$(ARCH)/src/smp/ipi.c \ |
| arch/$(ARCH)/src/smp/mps.c \ |
| arch/$(ARCH)/src/smp/smp.c |
| endif |
| /kernel/trunk/arch/amd64/include/ega.h |
|---|
| 0,0 → 1,0 |
| link ../../ia32/include/ega.h |
| Property changes: |
| Added: svn:special |
| +* |
| \ No newline at end of property |
| /kernel/trunk/arch/amd64/include/interrupt.h |
|---|
| 0,0 → 1,0 |
| link ../../ia32/include/interrupt.h |
| Property changes: |
| Added: svn:special |
| +* |
| \ No newline at end of property |
| /kernel/trunk/arch/amd64/include/fpu_context.h |
|---|
| 0,0 → 1,0 |
| link ../../ia32/include/fpu_context.h |
| Property changes: |
| Added: svn:special |
| +* |
| \ No newline at end of property |
| /kernel/trunk/arch/amd64/include/bios |
|---|
| 0,0 → 1,0 |
| link ../../ia32/include/bios |
| Property changes: |
| Added: svn:special |
| +* |
| \ No newline at end of property |
| /kernel/trunk/arch/amd64/include/i8042.h |
|---|
| 0,0 → 1,0 |
| link ../../ia32/include/i8042.h |
| Property changes: |
| Added: svn:special |
| +* |
| \ No newline at end of property |
| /kernel/trunk/arch/amd64/include/smp |
|---|
| 0,0 → 1,0 |
| link ../../ia32/include/smp |
| Property changes: |
| Added: svn:special |
| +* |
| \ No newline at end of property |
| /kernel/trunk/arch/amd64/include/i8254.h |
|---|
| 0,0 → 1,0 |
| link ../../ia32/include/i8254.h |
| Property changes: |
| Added: svn:special |
| +* |
| \ No newline at end of property |
| /kernel/trunk/arch/amd64/include/atomic.h |
|---|
| 0,0 → 1,0 |
| link ../../ia32/include/atomic.h |
| Property changes: |
| Added: svn:special |
| +* |
| \ No newline at end of property |
| /kernel/trunk/arch/amd64/include/boot/memmap.h |
|---|
| 0,0 → 1,0 |
| link ../../../ia32/include/boot/memmap.h |
| Property changes: |
| Added: svn:special |
| +* |
| \ No newline at end of property |
| /kernel/trunk/arch/amd64/include/boot/memmapasm.h |
|---|
| 0,0 → 1,0 |
| link ../../../ia32/include/boot/memmapasm.h |
| Property changes: |
| Added: svn:special |
| +* |
| \ No newline at end of property |
| /kernel/trunk/arch/amd64/include/boot/boot.h |
|---|
| 0,0 → 1,38 |
| /* |
| * Copyright (C) 2005 Ondrej Palkovsky |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * - Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * - Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * - The name of the author may not be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| #ifndef __amd64_BOOT_H__ |
| #define __amd64_BOOT_H__ |
| #define BOOTSTRAP_OFFSET 0x8000 |
| #define BOOT_OFFSET 0x100000 |
| #define MULTIBOOT_HEADER_MAGIC 0x1BADB002 |
| #define MULTIBOOT_HEADER_FLAGS 0x00010003 |
| #endif |
| /kernel/trunk/arch/amd64/include/i8259.h |
|---|
| 0,0 → 1,0 |
| link ../../ia32/include/i8259.h |
| Property changes: |
| Added: svn:special |
| +* |
| \ No newline at end of property |
| /kernel/trunk/arch/amd64/include/mm/memory_init.h |
|---|
| 0,0 → 1,0 |
| link ../../../ia32/include/mm/memory_init.h |
| Property changes: |
| Added: svn:special |
| +* |
| \ No newline at end of property |
| /kernel/trunk/arch/amd64/include/mm/page.h |
|---|
| 0,0 → 1,130 |
| /* |
| * Copyright (C) 2005 Ondrej Palkovsky |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * - Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * - Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * - The name of the author may not be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| #ifndef __amd64_PAGE_H__ |
| #define __amd64_PAGE_H__ |
| #ifndef __ASM__ |
| # include <mm/page.h> |
| # include <arch/mm/frame.h> |
| # include <arch/types.h> |
| #endif |
| #define PAGE_SIZE FRAME_SIZE |
| #ifndef __ASM__ |
| # define KA2PA(x) (((__address) (x)) - 0xffffffff80000000) |
| # define PA2KA(x) (((__address) (x)) + 0xffffffff80000000) |
| #else |
| # define KA2PA(x) ((x) - 0xffffffff80000000) |
| # define PA2KA(x) ((x) + 0xffffffff80000000) |
| #endif |
| #define PTL0_INDEX_ARCH(vaddr) (((vaddr)>>39)&0x1ff) |
| #define PTL1_INDEX_ARCH(vaddr) (((vaddr)>>30)&0x1ff) |
| #define PTL2_INDEX_ARCH(vaddr) (((vaddr)>>21)&0x1ff) |
| #define PTL3_INDEX_ARCH(vaddr) (((vaddr)>>12)&0x1ff) |
| #define GET_PTL0_ADDRESS_ARCH() ((pte_t *) read_cr3()) |
| #define GET_PTL1_ADDRESS_ARCH(ptl0, i) ((pte_t *) ((((__u64) ((pte_t *)(ptl0))[(i)].addr_12_31)<<12) | (((__u64) ((pte_t *)(ptl0))[(i)].addr_32_51)<<32 ))) |
| #define GET_PTL2_ADDRESS_ARCH(ptl1, i) ((pte_t *) ((((__u64) ((pte_t *)(ptl1))[(i)].addr_12_31)<<12) | (((__u64) ((pte_t *)(ptl1))[(i)].addr_32_51)<<32 ))) |
| #define GET_PTL3_ADDRESS_ARCH(ptl2, i) ((pte_t *) ((((__u64) ((pte_t *)(ptl2))[(i)].addr_12_31)<<12) | (((__u64) ((pte_t *)(ptl2))[(i)].addr_32_51)<<32 ))) |
| #define GET_FRAME_ADDRESS_ARCH(ptl3, i) ((__address *) ((((__u64) ((pte_t *)(ptl3))[(i)].addr_12_31)<<12) | (((__u64) ((pte_t *)(ptl3))[(i)].addr_32_51)<<32 ))) |
| #define SET_PTL0_ADDRESS_ARCH(ptl0) (write_cr3((__address) (ptl0))) |
| #define SET_PTL1_ADDRESS_ARCH(ptl0, i, a) set_pt_addr((pte_t *)(ptl0), (index_t)(i), a) |
| #define SET_PTL2_ADDRESS_ARCH(ptl1, i, a) set_pt_addr((pte_t *)(ptl1), (index_t)(i), a) |
| #define SET_PTL3_ADDRESS_ARCH(ptl2, i, a) set_pt_addr((pte_t *)(ptl2), (index_t)(i), a) |
| #define SET_FRAME_ADDRESS_ARCH(ptl3, i, a) set_pt_addr((pte_t *)(ptl3), (index_t)(i), a) |
| #define GET_PTL1_FLAGS_ARCH(ptl0, i) get_pt_flags((pte_t *)(ptl0), (index_t)(i)) |
| #define GET_PTL2_FLAGS_ARCH(ptl1, i) get_pt_flags((pte_t *)(ptl1), (index_t)(i)) |
| #define GET_PTL3_FLAGS_ARCH(ptl2, i) get_pt_flags((pte_t *)(ptl2), (index_t)(i)) |
| #define GET_FRAME_FLAGS_ARCH(ptl3, i) get_pt_flags((pte_t *)(ptl3), (index_t)(i)) |
| #define SET_PTL1_FLAGS_ARCH(ptl0, i, x) set_pt_flags((pte_t *)(ptl0), (index_t)(i), (x)) |
| #define SET_PTL2_FLAGS_ARCH(ptl1, i, x) set_pt_flags((pte_t *)(ptl1), (index_t)(i), (x)) |
| #define SET_PTL3_FLAGS_ARCH(ptl2, i, x) set_pt_flags((pte_t *)(ptl2), (index_t)(i), (x)) |
| #define SET_FRAME_FLAGS_ARCH(ptl3, i, x) set_pt_flags((pte_t *)(ptl3), (index_t)(i), (x)) |
| #ifndef __ASM__ |
| struct page_specifier { |
| unsigned present : 1; |
| unsigned writeable : 1; |
| unsigned uaccessible : 1; |
| unsigned page_write_through : 1; |
| unsigned page_cache_disable : 1; |
| unsigned accessed : 1; |
| unsigned dirty : 1; |
| unsigned unused: 1; |
| unsigned global : 1; |
| unsigned avl : 3; |
| unsigned addr_12_31 : 30; |
| unsigned addr_32_51 : 21; |
| unsigned no_execute : 1; |
| } __attribute__ ((packed)); |
| static inline int get_pt_flags(pte_t *pt, index_t i) |
| { |
| pte_t *p = &pt[i]; |
| return ( |
| (!p->page_cache_disable)<<PAGE_CACHEABLE_SHIFT | |
| (!p->present)<<PAGE_PRESENT_SHIFT | |
| p->uaccessible<<PAGE_USER_SHIFT | |
| 1<<PAGE_READ_SHIFT | |
| p->writeable<<PAGE_WRITE_SHIFT | |
| (!p->no_execute)<<PAGE_EXEC_SHIFT |
| ); |
| } |
| static inline void set_pt_addr(pte_t *pt, index_t i, __address a) |
| { |
| pte_t *p = &pt[i]; |
| p->addr_12_31 = (a >> 12) & 0xfffff; |
| p->addr_32_51 = a >> 32; |
| } |
| static inline void set_pt_flags(pte_t *pt, index_t i, int flags) |
| { |
| pte_t *p = &pt[i]; |
| p->page_cache_disable = !(flags & PAGE_CACHEABLE); |
| p->present = !(flags & PAGE_NOT_PRESENT); |
| p->uaccessible = (flags & PAGE_USER) != 0; |
| p->writeable = (flags & PAGE_WRITE) != 0; |
| p->no_execute = (flags & PAGE_EXEC) == 0; |
| } |
| extern void page_arch_init(void); |
| #endif |
| #endif |
| /kernel/trunk/arch/amd64/include/mm/asid.h |
|---|
| 0,0 → 1,36 |
| /* |
| * Copyright (C) 2005 Jakub Jermar |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * - Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * - Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * - The name of the author may not be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| #ifndef __amd64_ASID_H__ |
| #define __amd64_ASID_H__ |
| typedef int asid_t; |
| #define asid_get() 0 |
| #endif |
| /kernel/trunk/arch/amd64/include/mm/vm.h |
|---|
| 0,0 → 1,45 |
| /* |
| * Copyright (C) 2005 Ondrej Palkovsky |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * - Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * - Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * - The name of the author may not be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| #ifndef __amd64_VM_H__ |
| #define __amd64_VM_H__ |
| #include <arch/types.h> |
| #define KERNEL_ADDRESS_SPACE_START_ARCH (__address) 0xffffffff80000000 |
| #define KERNEL_ADDRESS_SPACE_END_ARCH (__address) 0xffffffffffffffff |
| #define USER_ADDRESS_SPACE_START_ARCH (__address) 0x0000000000000000 |
| #define USER_ADDRESS_SPACE_END_ARCH (__address) 0x00008fffffffffff |
| #define UTEXT_ADDRESS_ARCH 0x00001000 |
| #define USTACK_ADDRESS_ARCH (USER_ADDRESS_SPACE_END_ARCH-(PAGE_SIZE-1)) |
| #define UDATA_ADDRESS_ARCH 0x21000000 |
| #define vm_install_arch(vm) |
| #endif |
| /kernel/trunk/arch/amd64/include/mm/tlb.h |
|---|
| 0,0 → 1,34 |
| /* |
| * Copyright (C) 2005 Jakub Jermar |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * - Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * - Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * - The name of the author may not be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| #ifndef __amd64_TLB_H__ |
| #define __amd64_TLB_H__ |
| #define tlb_init_arch() |
| #endif |
| /kernel/trunk/arch/amd64/include/mm/frame.h |
|---|
| 0,0 → 1,38 |
| /* |
| * Copyright (C) 2005 Ondrej Palkovsky |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * - Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * - Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * - The name of the author may not be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| #ifndef __amd64_FRAME_H__ |
| #define __amd64_FRAME_H__ |
| #define FRAME_SIZE 4096 |
| #ifndef __ASM__ |
| extern void frame_arch_init(void); |
| #endif |
| #endif |
| /kernel/trunk/arch/amd64/include/mm/ptl.h |
|---|
| 0,0 → 1,43 |
| /* |
| * Copyright (C) 2005 Ondrej Palkovsky |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * - Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * - Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * - The name of the author may not be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| #ifndef __amd64_PTL_H_ |
| #define __amd64_PTL_H_ |
| #define PTL_NO_EXEC (1<<63) |
| #define PTL_ACCESSED (1<<5) |
| #define PTL_CACHE_DISABLE (1<<4) |
| #define PTL_CACHE_THROUGH (1<<3) |
| #define PTL_USER (1<<2) |
| #define PTL_WRITABLE (1<<1) |
| #define PTL_PRESENT 1 |
| #define PTL_2MB_PAGE (1<<7) |
| #endif |
| /kernel/trunk/arch/amd64/include/barrier.h |
|---|
| 0,0 → 1,0 |
| link ../../ia32/include/barrier.h |
| Property changes: |
| Added: svn:special |
| +* |
| \ No newline at end of property |
| /kernel/trunk/arch/amd64/include/context_offset.h |
|---|
| 0,0 → 1,10 |
| /* This file is automatically generated by gencontext.c. */ |
| #define OFFSET_SP 0x0 |
| #define OFFSET_PC 0x8 |
| #define OFFSET_RBX 0x10 |
| #define OFFSET_RBP 0x18 |
| #define OFFSET_R12 0x20 |
| #define OFFSET_R13 0x28 |
| #define OFFSET_R14 0x30 |
| #define OFFSET_R15 0x38 |
| #define OFFSET_IPL 0x40 |
| /kernel/trunk/arch/amd64/include/memstr.h |
|---|
| 0,0 → 1,136 |
| /* |
| * Copyright (C) 2005 Sergey Bondari |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * - Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * - Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * - The name of the author may not be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| #ifndef __amd64_MEMSTR_H__ |
| #define __amd64_MEMSTR_H__ |
| /** Copy memory |
| * |
| * Copy a given number of bytes (3rd argument) |
| * from the memory location defined by 2nd argument |
| * to the memory location defined by 1st argument. |
| * The memory areas cannot overlap. |
| * |
| * @param dst Destination |
| * @param src Source |
| * @param cnt Number of bytes |
| * @return Destination |
| */ |
| static inline void * memcpy(void * dst, const void * src, size_t cnt) |
| { |
| __native d0, d1, d2; |
| __asm__ __volatile__( |
| "rep movsq\n\t" |
| "movq %4, %%rcx\n\t" |
| "andq $7, %%rcx\n\t" |
| "jz 1f\n\t" |
| "rep movsb\n\t" |
| "1:\n" |
| : "=&c" (d0), "=&D" (d1), "=&S" (d2) |
| : "0" ((__native)(cnt / 8)), "g" ((__native)cnt), "1" ((__native) dst), "2" ((__native) src) |
| : "memory"); |
| return dst; |
| } |
| /** Compare memory regions for equality |
| * |
| * Compare a given number of bytes (3rd argument) |
| * at memory locations defined by 1st and 2nd argument |
| * for equality. If bytes are equal function returns 0. |
| * |
| * @param src Region 1 |
| * @param dst Region 2 |
| * @param cnt Number of bytes |
| * @return Zero if bytes are equal, non-zero otherwise |
| */ |
| static inline int memcmp(const void * src, const void * dst, size_t cnt) |
| { |
| __native d0, d1, d2; |
| __native ret; |
| __asm__ ( |
| "repe cmpsb\n\t" |
| "je 1f\n\t" |
| "movq %3, %0\n\t" |
| "addq $1, %0\n\t" |
| "1:\n" |
| : "=a" (ret), "=%S" (d0), "=&D" (d1), "=&c" (d2) |
| : "0" (0), "1" (src), "2" (dst), "3" ((__native)cnt) |
| ); |
| return ret; |
| } |
| /** Fill memory with words |
| * Fill a given number of words (2nd argument) |
| * at memory defined by 1st argument with the |
| * word value defined by 3rd argument. |
| * |
| * @param dst Destination |
| * @param cnt Number of words |
| * @param x Value to fill |
| */ |
| static inline void memsetw(__address dst, size_t cnt, __u16 x) |
| { |
| __native d0, d1; |
| __asm__ __volatile__ ( |
| "rep stosw\n\t" |
| : "=&D" (d0), "=&c" (d1), "=a" (x) |
| : "0" (dst), "1" ((__native)cnt), "2" (x) |
| : "memory" |
| ); |
| } |
| /** Fill memory with bytes |
| * Fill a given number of bytes (2nd argument) |
| * at memory defined by 1st argument with the |
| * word value defined by 3rd argument. |
| * |
| * @param dst Destination |
| * @param cnt Number of bytes |
| * @param x Value to fill |
| */ |
| static inline void memsetb(__address dst, size_t cnt, __u8 x) |
| { |
| __native d0, d1; |
| __asm__ __volatile__ ( |
| "rep stosb\n\t" |
| : "=&D" (d0), "=&c" (d1), "=a" (x) |
| : "0" (dst), "1" ((__native)cnt), "2" (x) |
| : "memory" |
| ); |
| } |
| #endif |
| /kernel/trunk/arch/amd64/include/context.h |
|---|
| 0,0 → 1,61 |
| /* |
| * Copyright (C) 2005 Ondrej Palkovsky |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * - Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * - Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * - The name of the author may not be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| #ifndef __amd64_CONTEXT_H__ |
| #define __amd64_CONTEXT_H__ |
| #ifndef __amd64_TYPES_H__ |
| # include <arch/types.h> |
| #endif |
| /* According to ABI the stack MUST be aligned on |
| * 16-byte boundary. If it is not, the va_arg calling will |
| * panic sooner or later |
| */ |
| #define SP_DELTA 16 |
| /* We include only registers that must be preserved |
| * during function call |
| */ |
| struct context { |
| __address sp; |
| __address pc; |
| __u64 rbx; |
| __u64 rbp; |
| __u64 r12; |
| __u64 r13; |
| __u64 r14; |
| __u64 r15; |
| ipl_t ipl; |
| } __attribute__ ((packed)); |
| #endif |
| /kernel/trunk/arch/amd64/include/asm.h |
|---|
| 0,0 → 1,223 |
| /* |
| * Copyright (C) 2005 Jakub Jermar |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * - Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * - Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * - The name of the author may not be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| #ifndef __amd64_ASM_H__ |
| #define __amd64_ASM_H__ |
| #include <arch/types.h> |
| #include <config.h> |
| void asm_delay_loop(__u32 t); |
| void asm_fake_loop(__u32 t); |
| /** Return base address of current stack. |
| * |
| * Return the base address of the current stack. |
| * The stack is assumed to be STACK_SIZE bytes long. |
| * The stack must start on page boundary. |
| */ |
| static inline __address get_stack_base(void) |
| { |
| __address v; |
| __asm__ volatile ("andq %%rsp, %0\n" : "=r" (v) : "0" (~((__u64)STACK_SIZE-1))); |
| return v; |
| } |
| static inline void cpu_sleep(void) { __asm__ volatile ("hlt\n"); }; |
| static inline void cpu_halt(void) { __asm__ volatile ("hlt\n"); }; |
| static inline __u8 inb(__u16 port) |
| { |
| __u8 out; |
| __asm__ volatile ( |
| "mov %1, %%dx\n" |
| "inb %%dx,%%al\n" |
| "mov %%al, %0\n" |
| :"=m"(out) |
| :"m"(port) |
| :"%rdx","%rax" |
| ); |
| return out; |
| } |
| static inline __u8 outb(__u16 port,__u8 b) |
| { |
| __asm__ volatile ( |
| "mov %0,%%dx\n" |
| "mov %1,%%al\n" |
| "outb %%al,%%dx\n" |
| : |
| :"m"( port), "m" (b) |
| :"%rdx","%rax" |
| ); |
| } |
| /** Enable interrupts. |
| * |
| * Enable interrupts and return previous |
| * value of EFLAGS. |
| * |
| * @return Old interrupt priority level. |
| */ |
| static inline ipl_t interrupts_enable(void) { |
| ipl_t v; |
| __asm__ volatile ( |
| "pushfq\n" |
| "popq %0\n" |
| "sti\n" |
| : "=r" (v) |
| ); |
| return v; |
| } |
| /** Disable interrupts. |
| * |
| * Disable interrupts and return previous |
| * value of EFLAGS. |
| * |
| * @return Old interrupt priority level. |
| */ |
| static inline ipl_t interrupts_disable(void) { |
| ipl_t v; |
| __asm__ volatile ( |
| "pushfq\n" |
| "popq %0\n" |
| "cli\n" |
| : "=r" (v) |
| ); |
| return v; |
| } |
| /** Restore interrupt priority level. |
| * |
| * Restore EFLAGS. |
| * |
| * @param ipl Saved interrupt priority level. |
| */ |
| static inline void interrupts_restore(ipl_t ipl) { |
| __asm__ volatile ( |
| "pushq %0\n" |
| "popfq\n" |
| : : "r" (ipl) |
| ); |
| } |
| /** Return interrupt priority level. |
| * |
| * Return EFLAFS. |
| * |
| * @return Current interrupt priority level. |
| */ |
| static inline ipl_t interrupts_read(void) { |
| ipl_t v; |
| __asm__ volatile ( |
| "pushfq\n" |
| "popq %0\n" |
| : "=r" (v) |
| ); |
| return v; |
| } |
| /** Read CR0 |
| * |
| * Return value in CR0 |
| * |
| * @return Value read. |
| */ |
| static inline __u64 read_cr0(void) |
| { |
| __u64 v; |
| __asm__ volatile ("movq %%cr0,%0\n" : "=r" (v)); |
| return v; |
| } |
| /** Read CR2 |
| * |
| * Return value in CR2 |
| * |
| * @return Value read. |
| */ |
| static inline __u64 read_cr2(void) |
| { |
| __u64 v; |
| __asm__ volatile ("movq %%cr2,%0\n" : "=r" (v)); |
| return v; |
| } |
| /** Write CR3 |
| * |
| * Write value to CR3. |
| * |
| * @param v Value to be written. |
| */ |
| static inline void write_cr3(__u64 v) |
| { |
| __asm__ volatile ("movq %0,%%cr3\n" : : "r" (v)); |
| } |
| /** Read CR3 |
| * |
| * Return value in CR3 |
| * |
| * @return Value read. |
| */ |
| static inline __u64 read_cr3(void) |
| { |
| __u64 v; |
| __asm__ volatile ("movq %%cr3,%0" : "=r" (v)); |
| return v; |
| } |
| /** Enable local APIC |
| * |
| * Enable local APIC in MSR. |
| */ |
| static inline void enable_l_apic_in_msr() |
| { |
| __asm__ volatile ( |
| "movl $0x1b, %%ecx\n" |
| "rdmsr\n" |
| "orl $(1<<11),%%eax\n" |
| "orl $(0xfee00000),%%eax\n" |
| "wrmsr\n" |
| : |
| : |
| :"%eax","%ecx","%edx" |
| ); |
| } |
| extern size_t interrupt_handler_size; |
| extern void interrupt_handlers(void); |
| #endif |
| /kernel/trunk/arch/amd64/include/types.h |
|---|
| 0,0 → 1,50 |
| /* |
| * Copyright (C) 2001-2004 Jakub Jermar |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * - Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * - Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * - The name of the author may not be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| #ifndef __amd64_TYPES_H__ |
| #define __amd64_TYPES_H__ |
| #define NULL 0 |
| typedef signed char __s8; |
| typedef unsigned char __u8; |
| typedef unsigned short __u16; |
| typedef unsigned int __u32; |
| typedef unsigned long long __u64; |
| typedef __u64 __address; |
| /* Flags of processor (return value of interrupts_disable()) */ |
| typedef __u64 ipl_t; |
| typedef __u64 __native; |
| typedef struct page_specifier pte_t; |
| #endif |
| /kernel/trunk/arch/amd64/include/byteorder.h |
|---|
| 0,0 → 1,36 |
| /* |
| * Copyright (C) 2005 Jakub Jermar |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * - Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * - Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * - The name of the author may not be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| #ifndef __amd64_BYTEORDER_H__ |
| #define __amd64_BYTEORDER_H__ |
| /* AMD64 is little-endian */ |
| #define __native_le2host(n) (n) |
| #define __u64_le2host(n) (n) |
| #endif |
| /kernel/trunk/arch/amd64/include/cpu.h |
|---|
| 0,0 → 1,60 |
| /* |
| * Copyright (C) 2001-2004 Jakub Jermar |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * - Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * - Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * - The name of the author may not be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| #ifndef __amd64_CPU_H__ |
| #define __amd64_CPU_H__ |
| #define EFER_MSR_NUM 0xc0000080 |
| #define AMD_SCE_FLAG 0 |
| #define AMD_LME_FLAG 8 |
| #define AMD_LMA_FLAG 10 |
| #define AMD_FFXSR_FLAG 14 |
| #define AMD_NXE_FLAG 11 |
| #ifndef __ASM__ |
| #include <typedefs.h> |
| #include <arch/pm.h> |
| struct cpu_arch { |
| int vendor; |
| int family; |
| int model; |
| int stepping; |
| struct tss *tss; |
| }; |
| extern void set_efer_flag(int flag); |
| extern __u64 read_efer_flag(void); |
| void cpu_setup_fpu(void); |
| #endif /* __ASM__ */ |
| #endif |
| /kernel/trunk/arch/amd64/include/arch.h |
|---|
| 0,0 → 1,32 |
| /* |
| * Copyright (C) 2005 Ondrej Palkovsky |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * - Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * - Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * - The name of the author may not be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| #ifndef __amd64_ARCH_H__ |
| #define __amd64_ARCH_H__ |
| #endif |
| /kernel/trunk/arch/amd64/include/faddr.h |
|---|
| 0,0 → 1,36 |
| /* |
| * Copyright (C) 2005 Ondrej Palkovsky |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * - Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * - Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * - The name of the author may not be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| #ifndef __amd64_FADDR_H__ |
| #define __amd64_FADDR_H__ |
| #include <arch/types.h> |
| #define FADDR(fptr) ((__address) (fptr)) |
| #endif |
| /kernel/trunk/arch/amd64/include/thread.h |
|---|
| 0,0 → 1,34 |
| /* |
| * Copyright (C) 2005 Ondrej Palkovsky |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * - Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * - Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * - The name of the author may not be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| #ifndef __amd64_THREAD_H__ |
| #define __amd64_THREAD_H__ |
| #define ARCH_THREAD_DATA |
| #endif |
| /kernel/trunk/arch/amd64/include/pm.h |
|---|
| 0,0 → 1,162 |
| /* |
| * Copyright (C) 2001-2004 Jakub Jermar |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * - Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * - Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * - The name of the author may not be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| #ifndef __amd64_PM_H__ |
| #define __amd64_PM_H__ |
| #ifndef __ASM__ |
| # include <arch/types.h> |
| # include <typedefs.h> |
| # include <arch/context.h> |
| #endif |
| #define IDT_ITEMS 64 |
| #define GDT_ITEMS 8 |
| #define NULL_DES 0 |
| #define KTEXT_DES 1 |
| #define KDATA_DES 2 |
| #define UTEXT_DES 3 |
| #define UDATA_DES 4 |
| #define KTEXT32_DES 5 |
| #define TSS_DES 6 |
| #define gdtselector(des) ((des)<<3) |
| #define idtselector(des) ((des)<<4) |
| #define PL_KERNEL 0 |
| #define PL_USER 3 |
| #define AR_PRESENT (1<<7) |
| #define AR_DATA (2<<3) |
| #define AR_CODE (3<<3) |
| #define AR_WRITABLE (1<<1) |
| #define AR_READABLE (1<<1) |
| #define AR_TSS (0x9) |
| #define AR_INTERRUPT (0xe) |
| #define AR_TRAP (0xf) |
| #define DPL_KERNEL (PL_KERNEL<<5) |
| #define DPL_USER (PL_USER<<5) |
| #define IO_MAP_BASE (104) |
| #ifndef __ASM__ |
| struct descriptor { |
| unsigned limit_0_15: 16; |
| unsigned base_0_15: 16; |
| unsigned base_16_23: 8; |
| unsigned access: 8; |
| unsigned limit_16_19: 4; |
| unsigned available: 1; |
| unsigned longmode: 1; |
| unsigned special: 1; |
| unsigned granularity : 1; |
| unsigned base_24_31: 8; |
| } __attribute__ ((packed)); |
| struct tss_descriptor { |
| unsigned limit_0_15: 16; |
| unsigned base_0_15: 16; |
| unsigned base_16_23: 8; |
| unsigned type: 4; |
| unsigned : 1; |
| unsigned dpl : 2; |
| unsigned present : 1; |
| unsigned limit_16_19: 4; |
| unsigned available: 1; |
| unsigned : 2; |
| unsigned granularity : 1; |
| unsigned base_24_31: 8; |
| unsigned base_32_63 : 32; |
| unsigned : 32; |
| } __attribute__ ((packed)); |
| struct idescriptor { |
| unsigned offset_0_15: 16; |
| unsigned selector: 16; |
| unsigned ist:3; |
| unsigned unused: 5; |
| unsigned type: 5; |
| unsigned dpl: 2; |
| unsigned present : 1; |
| unsigned offset_16_31: 16; |
| unsigned offset_32_63: 32; |
| unsigned : 32; |
| } __attribute__ ((packed)); |
| struct ptr_16_64 { |
| __u16 limit; |
| __u64 base; |
| } __attribute__ ((packed)); |
| struct ptr_16_32 { |
| __u16 limit; |
| __u32 base; |
| } __attribute__ ((packed)); |
| struct tss { |
| __u32 reserve1; |
| __u64 rsp0; |
| __u64 rsp1; |
| __u64 rsp2; |
| __u64 reserve2; |
| __u64 ist1; |
| __u64 ist2; |
| __u64 ist3; |
| __u64 ist4; |
| __u64 ist5; |
| __u64 ist6; |
| __u64 ist7; |
| __u64 reserve3; |
| __u16 reserve4; |
| __u16 iomap; |
| } __attribute__ ((packed)); |
| extern struct tss *tss_p; |
| extern struct descriptor gdt[]; |
| extern struct idescriptor idt[]; |
| extern struct ptr_16_64 gdtr; |
| extern struct ptr_16_32 real_bootstrap_gdtr; |
| extern void pm_init(void); |
| extern void gdt_tss_setbase(struct descriptor *d, __address base); |
| extern void gdt_tss_setlimit(struct descriptor *d, __u32 limit); |
| extern void idt_init(void); |
| extern void idt_setoffset(struct idescriptor *d, __address offset); |
| extern void tss_initialize(struct tss *t); |
| #endif /* __ASM__ */ |
| #endif |
| /kernel/trunk/arch/amd64/include/cpuid.h |
|---|
| 0,0 → 1,58 |
| /* |
| * Copyright (C) 2001-2004 Ondrej Palkovsky |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * - Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * - Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * - The name of the author may not be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| #ifndef __CPUID_H__ |
| #define __CPUID_H__ |
| #define AMD_CPUID_EXTENDED 0x80000001 |
| #define AMD_EXT_NOEXECUTE 20 |
| #define INTEL_CPUID_STANDARD 0x1 |
| #define INTEL_SSE2 26 |
| #define INTEL_FXSAVE 24 |
| #ifndef __ASM__ |
| #include <arch/types.h> |
| struct cpu_info { |
| __u32 cpuid_eax; |
| __u32 cpuid_ebx; |
| __u32 cpuid_ecx; |
| __u32 cpuid_edx; |
| } __attribute__ ((packed)); |
| extern int has_cpuid(void); |
| extern void cpuid(__u32 cmd, cpu_info_t *info); |
| extern __u64 rdtsc(void); |
| #endif /* __ASM__ */ |
| #endif |
| /kernel/trunk/arch/amd64/include/fmath.h |
|---|
| 0,0 → 1,64 |
| /* |
| * Copyright (C) 2005 Josef Cejka |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * - Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * - Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * - The name of the author may not be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| #include <arch/types.h> |
| #define FMATH_EXPONENT_BIAS 1023 |
| typedef unsigned char fmath_ld_descr_t[8]; |
| typedef union { double bf; unsigned char ldd[8]; } fmath_ld_union_t; |
| /**returns exponent in binary encoding*/ |
| signed short fmath_get_binary_exponent(double num); |
| /**returns exponent in decimal encoding*/ |
| double fmath_get_decimal_exponent(double num); |
| /**returns mantisa in binary encoding */ |
| __u64 fmath_get_binary_mantisa(double num) ; |
| /** Function for extract integer part from double |
| * @param num input value |
| * @param intp integer part of num |
| * @return non-integer part |
| */ |
| double fmath_fint(double num, double *intp); |
| /** count base^exponent from positive exponent |
| * @param base |
| * @param exponent - Must be > 0.0 |
| * @return base^exponent or 0.0 (if exponent <=0.0) |
| */ |
| double fmath_dpow(double base, double exponent) ; |
| /** return 1, if num is NaN */ |
| int fmath_is_nan(double num); |
| /** return 1, if fmath is a infinity */ |
| int fmath_is_infinity(double num); |
| /kernel/trunk/arch/amd64/include/arg.h |
|---|
| 0,0 → 1,34 |
| /* |
| * Copyright (C) 2005 Ondrej Palkovsky |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * - Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * - Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * - The name of the author may not be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| #ifndef __amd64_ARG_H__ |
| #define __amd64_ARG_H__ |
| #include <stdarg.h> |
| #endif |
| /kernel/trunk/arch/amd64/_link.ld.in |
|---|
| 0,0 → 1,72 |
| /** AMD64 linker script |
| * |
| * umapped section: |
| * kernel text |
| * kernel data |
| * mapped section: |
| * kernel text |
| * kernel data |
| */ |
| #define __ASM__ |
| #include <arch/boot/boot.h> |
| #include <arch/mm/page.h> |
| ENTRY(kernel_image_start) |
| SECTIONS { |
| .unmapped BOOTSTRAP_OFFSET: AT (BOOTSTRAP_OFFSET) { |
| unmapped_ktext_start = .; |
| *(K_TEXT_START); |
| *(K_TEXT_START_2); |
| unmapped_ktext_end = .; |
| unmapped_kdata_start = .; |
| *(K_DATA_START); |
| unmapped_kdata_end = .; |
| } |
| .mapped (PA2KA(BOOT_OFFSET+BOOTSTRAP_OFFSET)+SIZEOF(.unmapped)) : AT (BOOTSTRAP_OFFSET+SIZEOF(.unmapped)) { |
| ktext_start = .; |
| *(BOOT_DATA); |
| *(.text); |
| ktext_end = .; |
| kdata_start = .; |
| *(.data); /* initialized data */ |
| *(.rodata*); /* string literals */ |
| hardcoded_load_address = .; |
| QUAD(PA2KA(BOOT_OFFSET+BOOTSTRAP_OFFSET)); |
| hardcoded_ktext_size = .; |
| QUAD(ktext_end - ktext_start + (unmapped_ktext_end - unmapped_ktext_start)); |
| hardcoded_kdata_size = .; |
| QUAD(kdata_end - kdata_start + (unmapped_kdata_end - unmapped_kdata_start)); |
| hardcoded_unmapped_ktext_size = .; |
| LONG(unmapped_ktext_end - unmapped_ktext_start); |
| hardcoded_unmapped_kdata_size = .; |
| LONG(unmapped_kdata_end - unmapped_kdata_start); |
| *(COMMON); /* global variables */ |
| *(.eh_frame); |
| *(.bss); /* uninitialized static variables */ |
| symbol_table = .; |
| *(symtab.*); /* Symbol table, must be LAST symbol!*/ |
| kdata_end = .; |
| } |
| _hardcoded_kernel_size = (ktext_end - ktext_start) + (unmapped_ktext_end - unmapped_ktext_start) + (kdata_end - kdata_start) + (unmapped_kdata_end - unmapped_kdata_start); |
| /* Symbols that need to be accessed both from real mode & long mode */ |
| /* e820*_boot is real mode (pre-above-1MB-move), e820* is */ |
| /* kernel mapped above-1MB-physical copied symbol */ |
| e820table_boot = KA2PA(e820table) - BOOT_OFFSET; |
| e820counter_boot = KA2PA(e820counter) - BOOT_OFFSET; |
| /* real_bootstrap_gdtr is mapped real_bootstrap_gdtr_boot */ |
| /* It is physically outside of kernel area, we have to access */ |
| /* it after modification from long mode for booting */ |
| /* SMP slave processors */ |
| real_bootstrap_gdtr = PA2KA(real_bootstrap_gdtr_boot); |
| } |
| /kernel/trunk/arch/amd64/boot/Makefile |
|---|
| 0,0 → 1,17 |
| .PHONY: build clean |
| build: boot.bin |
| dd if=boot.bin of=../../../image.bin bs=512 conv=sync |
| -cat ../../../kernel.bin >> ../../../image.bin |
| dd if=/dev/zero of=../../../image.bin bs=1 seek=1474559 count=1 |
| boot.bin: boot.o |
| $(LD) -T boot.ld -entry _start_0x7c00 --oformat binary boot.o -o $@ |
| boot.o: boot.S |
| $(CC) -E -DKERNEL_SIZE=$(KERNEL_SIZE) boot.S > boot.s |
| $(AS) boot.s -o $@ |
| rm boot.s |
| clean: |
| -rm -f boot.o boot.bin ../../../image.bin |
| /kernel/trunk/arch/amd64/boot/boot.ld |
|---|
| 0,0 → 1,4 |
| OUTPUT_FORMAT(binary) |
| SECTIONS { |
| .text 0x7c00 : AT (0x0) { *(.text) } |
| } |
| /kernel/trunk/arch/amd64/boot/boot.S |
|---|
| 0,0 → 1,151 |
| # |
| # Copyright (C) 2001-2004 Jakub Jermar |
| # All rights reserved. |
| # |
| # Redistribution and use in source and binary forms, with or without |
| # modification, are permitted provided that the following conditions |
| # are met: |
| # |
| # - Redistributions of source code must retain the above copyright |
| # notice, this list of conditions and the following disclaimer. |
| # - Redistributions in binary form must reproduce the above copyright |
| # notice, this list of conditions and the following disclaimer in the |
| # documentation and/or other materials provided with the distribution. |
| # - The name of the author may not be used to endorse or promote products |
| # derived from this software without specific prior written permission. |
| # |
| # THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| # IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| # OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| # IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| # INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| # NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| # DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| # THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| # (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| # THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| # |
| # This is a very primitive boot.s |
| # It assumes that the first sector of the kernel image is found |
| # on head 0, track 0, sector 2 of the first floppy drive (1440K). |
| # Next kernel sectors follow on disk sector 3, 4, ... |
| # |
| # KERNEL_SIZE is passed from the outside to the preprocessor |
| #if (KERNEL_SIZE%512>0) |
| #define TAIL 1 |
| #else |
| #define TAIL 0 |
| #endif |
| #define SECTORS (KERNEL_SIZE/512+TAIL) |
| .text |
| .global _start_0x7c00 |
| .code16 |
| _start_0x7c00: |
| xorw %ax,%ax # reset, %al will be used below |
| movw %ax,%dx # fd0, %dh and %dl will be used below |
| movw %dx,%ds |
| movw %dx,%ss # initialize stack |
| movw $stack,%sp |
| int $0x13 # reset floppy |
| jc stop_trying |
| movw %dx,%ds |
| movw %dx,%ss |
| movw $0x7c00,%sp |
| movw $0xffe0,%si # after next increment, %si will become 0x0000 |
| movw %si,%es |
| movw $0x8000,%bx # at %es:%bx |
| movl $(SECTORS),%edi |
| read_next: |
| test %edi,%edi |
| jnz read_sectors |
| movb $12,%al |
| movw $0x3f2,%dx |
| outb %al,%dx |
| movb $('$'),%al |
| call echo_mark |
| jmpl $0,$0x8000 |
| read_sectors: |
| movb $('.'),%al |
| call echo_mark |
| decl %edi |
| incw logical_sector |
| movw %es,%si |
| addw $0x20,%si |
| movw %si,%es |
| movw logical_sector,%ax |
| divb sectors |
| movb %ah,%cl |
| incb %cl # sector |
| movb %al,%ch |
| shrb $1,%ch # track |
| movb %al,%dh |
| andb $1,%dh # head |
| movw $0x0201,%ax |
| int $0x13 |
| jnc read_next |
| movb $('R'),%al |
| call echo_mark |
| xorw %ax,%ax # try to reset |
| movw %ax,%dx # fd0 |
| int $0x13 |
| jnc read_next |
| stop_trying: |
| movb $('F'),%al |
| call echo_mark |
| cli |
| hlt |
| CH=4 |
| echo_mark: |
| push %bp |
| movw %sp,%bp |
| pusha |
| movb $0xe,%ah |
| movb $7,%bl |
| int $0x10 |
| popa |
| pop %bp |
| ret |
| # current logical sector from the beginning of the disk |
| logical_sector: |
| .word 0 |
| # number of sectors per track on 1440 floppy |
| sectors: |
| .byte 18 |
| # boot floppy signature |
| .org 0x1fe |
| boot_floppy_signature: |
| .byte 0x55 |
| .byte 0xaa |
| stack: |