1/* 2 * 3 * Copyright (C) 1991, 1992 Linus Torvalds 4 * 5 * Enhanced CPU detection and feature setting code by Mike Jagdis 6 * and Martin Mares, November 1997. 7 */ 8 9.text 10#include <linux/threads.h> 11#include <linux/init.h> 12#include <linux/linkage.h> 13#include <asm/segment.h> 14#include <asm/page_types.h> 15#include <asm/pgtable_types.h> 16#include <asm/cache.h> 17#include <asm/thread_info.h> 18#include <asm/asm-offsets.h> 19#include <asm/setup.h> 20#include <asm/processor-flags.h> 21#include <asm/msr-index.h> 22#include <asm/cpufeatures.h> 23#include <asm/percpu.h> 24#include <asm/nops.h> 25#include <asm/bootparam.h> 26 27/* Physical address */ 28#define pa(X) ((X) - __PAGE_OFFSET) 29 30/* 31 * References to members of the new_cpu_data structure. 32 */ 33 34#define X86 new_cpu_data+CPUINFO_x86 35#define X86_VENDOR new_cpu_data+CPUINFO_x86_vendor 36#define X86_MODEL new_cpu_data+CPUINFO_x86_model 37#define X86_MASK new_cpu_data+CPUINFO_x86_mask 38#define X86_HARD_MATH new_cpu_data+CPUINFO_hard_math 39#define X86_CPUID new_cpu_data+CPUINFO_cpuid_level 40#define X86_CAPABILITY new_cpu_data+CPUINFO_x86_capability 41#define X86_VENDOR_ID new_cpu_data+CPUINFO_x86_vendor_id 42 43/* 44 * This is how much memory in addition to the memory covered up to 45 * and including _end we need mapped initially. 46 * We need: 47 * (KERNEL_IMAGE_SIZE/4096) / 1024 pages (worst case, non PAE) 48 * (KERNEL_IMAGE_SIZE/4096) / 512 + 4 pages (worst case for PAE) 49 * 50 * Modulo rounding, each megabyte assigned here requires a kilobyte of 51 * memory, which is currently unreclaimed. 52 * 53 * This should be a multiple of a page. 54 * 55 * KERNEL_IMAGE_SIZE should be greater than pa(_end) 56 * and small than max_low_pfn, otherwise will waste some page table entries 57 */ 58 59#if PTRS_PER_PMD > 1 60#define PAGE_TABLE_SIZE(pages) (((pages) / PTRS_PER_PMD) + PTRS_PER_PGD) 61#else 62#define PAGE_TABLE_SIZE(pages) ((pages) / PTRS_PER_PGD) 63#endif 64 65/* 66 * Number of possible pages in the lowmem region. 67 * 68 * We shift 2 by 31 instead of 1 by 32 to the left in order to avoid a 69 * gas warning about overflowing shift count when gas has been compiled 70 * with only a host target support using a 32-bit type for internal 71 * representation. 72 */ 73LOWMEM_PAGES = (((2<<31) - __PAGE_OFFSET) >> PAGE_SHIFT) 74 75/* Enough space to fit pagetables for the low memory linear map */ 76MAPPING_BEYOND_END = PAGE_TABLE_SIZE(LOWMEM_PAGES) << PAGE_SHIFT 77 78/* 79 * Worst-case size of the kernel mapping we need to make: 80 * a relocatable kernel can live anywhere in lowmem, so we need to be able 81 * to map all of lowmem. 82 */ 83KERNEL_PAGES = LOWMEM_PAGES 84 85INIT_MAP_SIZE = PAGE_TABLE_SIZE(KERNEL_PAGES) * PAGE_SIZE 86RESERVE_BRK(pagetables, INIT_MAP_SIZE) 87 88/* 89 * 32-bit kernel entrypoint; only used by the boot CPU. On entry, 90 * %esi points to the real-mode code as a 32-bit pointer. 91 * CS and DS must be 4 GB flat segments, but we don't depend on 92 * any particular GDT layout, because we load our own as soon as we 93 * can. 94 */ 95__HEAD 96ENTRY(startup_32) 97 movl pa(stack_start),%ecx 98 99 /* test KEEP_SEGMENTS flag to see if the bootloader is asking 100 us to not reload segments */ 101 testb $KEEP_SEGMENTS, BP_loadflags(%esi) 102 jnz 2f 103 104/* 105 * Set segments to known values. 106 */ 107 lgdt pa(boot_gdt_descr) 108 movl $(__BOOT_DS),%eax 109 movl %eax,%ds 110 movl %eax,%es 111 movl %eax,%fs 112 movl %eax,%gs 113 movl %eax,%ss 1142: 115 leal -__PAGE_OFFSET(%ecx),%esp 116 117/* 118 * Clear BSS first so that there are no surprises... 119 */ 120 cld 121 xorl %eax,%eax 122 movl $pa(__bss_start),%edi 123 movl $pa(__bss_stop),%ecx 124 subl %edi,%ecx 125 shrl $2,%ecx 126 rep ; stosl 127/* 128 * Copy bootup parameters out of the way. 129 * Note: %esi still has the pointer to the real-mode data. 130 * With the kexec as boot loader, parameter segment might be loaded beyond 131 * kernel image and might not even be addressable by early boot page tables. 132 * (kexec on panic case). Hence copy out the parameters before initializing 133 * page tables. 134 */ 135 movl $pa(boot_params),%edi 136 movl $(PARAM_SIZE/4),%ecx 137 cld 138 rep 139 movsl 140 movl pa(boot_params) + NEW_CL_POINTER,%esi 141 andl %esi,%esi 142 jz 1f # No command line 143 movl $pa(boot_command_line),%edi 144 movl $(COMMAND_LINE_SIZE/4),%ecx 145 rep 146 movsl 1471: 148 149#ifdef CONFIG_OLPC 150 /* save OFW's pgdir table for later use when calling into OFW */ 151 movl %cr3, %eax 152 movl %eax, pa(olpc_ofw_pgd) 153#endif 154 155#ifdef CONFIG_MICROCODE 156 /* Early load ucode on BSP. */ 157 call load_ucode_bsp 158#endif 159 160/* 161 * Initialize page tables. This creates a PDE and a set of page 162 * tables, which are located immediately beyond __brk_base. The variable 163 * _brk_end is set up to point to the first "safe" location. 164 * Mappings are created both at virtual address 0 (identity mapping) 165 * and PAGE_OFFSET for up to _end. 166 */ 167#ifdef CONFIG_X86_PAE 168 169 /* 170 * In PAE mode initial_page_table is statically defined to contain 171 * enough entries to cover the VMSPLIT option (that is the top 1, 2 or 3 172 * entries). The identity mapping is handled by pointing two PGD entries 173 * to the first kernel PMD. 174 * 175 * Note the upper half of each PMD or PTE are always zero at this stage. 176 */ 177 178#define KPMDS (((-__PAGE_OFFSET) >> 30) & 3) /* Number of kernel PMDs */ 179 180 xorl %ebx,%ebx /* %ebx is kept at zero */ 181 182 movl $pa(__brk_base), %edi 183 movl $pa(initial_pg_pmd), %edx 184 movl $PTE_IDENT_ATTR, %eax 18510: 186 leal PDE_IDENT_ATTR(%edi),%ecx /* Create PMD entry */ 187 movl %ecx,(%edx) /* Store PMD entry */ 188 /* Upper half already zero */ 189 addl $8,%edx 190 movl $512,%ecx 19111: 192 stosl 193 xchgl %eax,%ebx 194 stosl 195 xchgl %eax,%ebx 196 addl $0x1000,%eax 197 loop 11b 198 199 /* 200 * End condition: we must map up to the end + MAPPING_BEYOND_END. 201 */ 202 movl $pa(_end) + MAPPING_BEYOND_END + PTE_IDENT_ATTR, %ebp 203 cmpl %ebp,%eax 204 jb 10b 2051: 206 addl $__PAGE_OFFSET, %edi 207 movl %edi, pa(_brk_end) 208 shrl $12, %eax 209 movl %eax, pa(max_pfn_mapped) 210 211 /* Do early initialization of the fixmap area */ 212 movl $pa(initial_pg_fixmap)+PDE_IDENT_ATTR,%eax 213 movl %eax,pa(initial_pg_pmd+0x1000*KPMDS-8) 214#else /* Not PAE */ 215 216page_pde_offset = (__PAGE_OFFSET >> 20); 217 218 movl $pa(__brk_base), %edi 219 movl $pa(initial_page_table), %edx 220 movl $PTE_IDENT_ATTR, %eax 22110: 222 leal PDE_IDENT_ATTR(%edi),%ecx /* Create PDE entry */ 223 movl %ecx,(%edx) /* Store identity PDE entry */ 224 movl %ecx,page_pde_offset(%edx) /* Store kernel PDE entry */ 225 addl $4,%edx 226 movl $1024, %ecx 22711: 228 stosl 229 addl $0x1000,%eax 230 loop 11b 231 /* 232 * End condition: we must map up to the end + MAPPING_BEYOND_END. 233 */ 234 movl $pa(_end) + MAPPING_BEYOND_END + PTE_IDENT_ATTR, %ebp 235 cmpl %ebp,%eax 236 jb 10b 237 addl $__PAGE_OFFSET, %edi 238 movl %edi, pa(_brk_end) 239 shrl $12, %eax 240 movl %eax, pa(max_pfn_mapped) 241 242 /* Do early initialization of the fixmap area */ 243 movl $pa(initial_pg_fixmap)+PDE_IDENT_ATTR,%eax 244 movl %eax,pa(initial_page_table+0xffc) 245#endif 246 247#ifdef CONFIG_PARAVIRT 248 /* This is can only trip for a broken bootloader... */ 249 cmpw $0x207, pa(boot_params + BP_version) 250 jb default_entry 251 252 /* Paravirt-compatible boot parameters. Look to see what architecture 253 we're booting under. */ 254 movl pa(boot_params + BP_hardware_subarch), %eax 255 cmpl $num_subarch_entries, %eax 256 jae bad_subarch 257 258 movl pa(subarch_entries)(,%eax,4), %eax 259 subl $__PAGE_OFFSET, %eax 260 jmp *%eax 261 262bad_subarch: 263WEAK(lguest_entry) 264WEAK(xen_entry) 265 /* Unknown implementation; there's really 266 nothing we can do at this point. */ 267 ud2a 268 269 __INITDATA 270 271subarch_entries: 272 .long default_entry /* normal x86/PC */ 273 .long lguest_entry /* lguest hypervisor */ 274 .long xen_entry /* Xen hypervisor */ 275 .long default_entry /* Moorestown MID */ 276num_subarch_entries = (. - subarch_entries) / 4 277.previous 278#else 279 jmp default_entry 280#endif /* CONFIG_PARAVIRT */ 281 282#ifdef CONFIG_HOTPLUG_CPU 283/* 284 * Boot CPU0 entry point. It's called from play_dead(). Everything has been set 285 * up already except stack. We just set up stack here. Then call 286 * start_secondary(). 287 */ 288ENTRY(start_cpu0) 289 movl stack_start, %ecx 290 movl %ecx, %esp 291 jmp *(initial_code) 292ENDPROC(start_cpu0) 293#endif 294 295/* 296 * Non-boot CPU entry point; entered from trampoline.S 297 * We can't lgdt here, because lgdt itself uses a data segment, but 298 * we know the trampoline has already loaded the boot_gdt for us. 299 * 300 * If cpu hotplug is not supported then this code can go in init section 301 * which will be freed later 302 */ 303ENTRY(startup_32_smp) 304 cld 305 movl $(__BOOT_DS),%eax 306 movl %eax,%ds 307 movl %eax,%es 308 movl %eax,%fs 309 movl %eax,%gs 310 movl pa(stack_start),%ecx 311 movl %eax,%ss 312 leal -__PAGE_OFFSET(%ecx),%esp 313 314#ifdef CONFIG_MICROCODE 315 /* Early load ucode on AP. */ 316 call load_ucode_ap 317#endif 318 319default_entry: 320#define CR0_STATE (X86_CR0_PE | X86_CR0_MP | X86_CR0_ET | \ 321 X86_CR0_NE | X86_CR0_WP | X86_CR0_AM | \ 322 X86_CR0_PG) 323 movl $(CR0_STATE & ~X86_CR0_PG),%eax 324 movl %eax,%cr0 325 326/* 327 * We want to start out with EFLAGS unambiguously cleared. Some BIOSes leave 328 * bits like NT set. This would confuse the debugger if this code is traced. So 329 * initialize them properly now before switching to protected mode. That means 330 * DF in particular (even though we have cleared it earlier after copying the 331 * command line) because GCC expects it. 332 */ 333 pushl $0 334 popfl 335 336/* 337 * New page tables may be in 4Mbyte page mode and may be using the global pages. 338 * 339 * NOTE! If we are on a 486 we may have no cr4 at all! Specifically, cr4 exists 340 * if and only if CPUID exists and has flags other than the FPU flag set. 341 */ 342 movl $-1,pa(X86_CPUID) # preset CPUID level 343 movl $X86_EFLAGS_ID,%ecx 344 pushl %ecx 345 popfl # set EFLAGS=ID 346 pushfl 347 popl %eax # get EFLAGS 348 testl $X86_EFLAGS_ID,%eax # did EFLAGS.ID remained set? 349 jz enable_paging # hw disallowed setting of ID bit 350 # which means no CPUID and no CR4 351 352 xorl %eax,%eax 353 cpuid 354 movl %eax,pa(X86_CPUID) # save largest std CPUID function 355 356 movl $1,%eax 357 cpuid 358 andl $~1,%edx # Ignore CPUID.FPU 359 jz enable_paging # No flags or only CPUID.FPU = no CR4 360 361 movl pa(mmu_cr4_features),%eax 362 movl %eax,%cr4 363 364 testb $X86_CR4_PAE, %al # check if PAE is enabled 365 jz enable_paging 366 367 /* Check if extended functions are implemented */ 368 movl $0x80000000, %eax 369 cpuid 370 /* Value must be in the range 0x80000001 to 0x8000ffff */ 371 subl $0x80000001, %eax 372 cmpl $(0x8000ffff-0x80000001), %eax 373 ja enable_paging 374 375 /* Clear bogus XD_DISABLE bits */ 376 call verify_cpu 377 378 mov $0x80000001, %eax 379 cpuid 380 /* Execute Disable bit supported? */ 381 btl $(X86_FEATURE_NX & 31), %edx 382 jnc enable_paging 383 384 /* Setup EFER (Extended Feature Enable Register) */ 385 movl $MSR_EFER, %ecx 386 rdmsr 387 388 btsl $_EFER_NX, %eax 389 /* Make changes effective */ 390 wrmsr 391 392 /* 393 * And make sure that all the mappings we set up have NX set from 394 * the beginning. 395 */ 396 orl $(1 << (_PAGE_BIT_NX - 32)), pa(__supported_pte_mask + 4) 397 398enable_paging: 399 400/* 401 * Enable paging 402 */ 403 movl $pa(initial_page_table), %eax 404 movl %eax,%cr3 /* set the page table pointer.. */ 405 movl $CR0_STATE,%eax 406 movl %eax,%cr0 /* ..and set paging (PG) bit */ 407 ljmp $__BOOT_CS,$1f /* Clear prefetch and normalize %eip */ 4081: 409 /* Shift the stack pointer to a virtual address */ 410 addl $__PAGE_OFFSET, %esp 411 412/* 413 * start system 32-bit setup. We need to re-do some of the things done 414 * in 16-bit mode for the "real" operations. 415 */ 416 movl setup_once_ref,%eax 417 andl %eax,%eax 418 jz 1f # Did we do this already? 419 call *%eax 4201: 421 422/* 423 * Check if it is 486 424 */ 425 movb $4,X86 # at least 486 426 cmpl $-1,X86_CPUID 427 je is486 428 429 /* get vendor info */ 430 xorl %eax,%eax # call CPUID with 0 -> return vendor ID 431 cpuid 432 movl %eax,X86_CPUID # save CPUID level 433 movl %ebx,X86_VENDOR_ID # lo 4 chars 434 movl %edx,X86_VENDOR_ID+4 # next 4 chars 435 movl %ecx,X86_VENDOR_ID+8 # last 4 chars 436 437 orl %eax,%eax # do we have processor info as well? 438 je is486 439 440 movl $1,%eax # Use the CPUID instruction to get CPU type 441 cpuid 442 movb %al,%cl # save reg for future use 443 andb $0x0f,%ah # mask processor family 444 movb %ah,X86 445 andb $0xf0,%al # mask model 446 shrb $4,%al 447 movb %al,X86_MODEL 448 andb $0x0f,%cl # mask mask revision 449 movb %cl,X86_MASK 450 movl %edx,X86_CAPABILITY 451 452is486: 453 movl $0x50022,%ecx # set AM, WP, NE and MP 454 movl %cr0,%eax 455 andl $0x80000011,%eax # Save PG,PE,ET 456 orl %ecx,%eax 457 movl %eax,%cr0 458 459 lgdt early_gdt_descr 460 lidt idt_descr 461 ljmp $(__KERNEL_CS),$1f 4621: movl $(__KERNEL_DS),%eax # reload all the segment registers 463 movl %eax,%ss # after changing gdt. 464 465 movl $(__USER_DS),%eax # DS/ES contains default USER segment 466 movl %eax,%ds 467 movl %eax,%es 468 469 movl $(__KERNEL_PERCPU), %eax 470 movl %eax,%fs # set this cpu's percpu 471 472 movl $(__KERNEL_STACK_CANARY),%eax 473 movl %eax,%gs 474 475 xorl %eax,%eax # Clear LDT 476 lldt %ax 477 478 pushl $0 # fake return address for unwinder 479 jmp *(initial_code) 480 481#include "verify_cpu.S" 482 483/* 484 * setup_once 485 * 486 * The setup work we only want to run on the BSP. 487 * 488 * Warning: %esi is live across this function. 489 */ 490__INIT 491setup_once: 492 /* 493 * Set up a idt with 256 interrupt gates that push zero if there 494 * is no error code and then jump to early_idt_handler_common. 495 * It doesn't actually load the idt - that needs to be done on 496 * each CPU. Interrupts are enabled elsewhere, when we can be 497 * relatively sure everything is ok. 498 */ 499 500 movl $idt_table,%edi 501 movl $early_idt_handler_array,%eax 502 movl $NUM_EXCEPTION_VECTORS,%ecx 5031: 504 movl %eax,(%edi) 505 movl %eax,4(%edi) 506 /* interrupt gate, dpl=0, present */ 507 movl $(0x8E000000 + __KERNEL_CS),2(%edi) 508 addl $EARLY_IDT_HANDLER_SIZE,%eax 509 addl $8,%edi 510 loop 1b 511 512 movl $256 - NUM_EXCEPTION_VECTORS,%ecx 513 movl $ignore_int,%edx 514 movl $(__KERNEL_CS << 16),%eax 515 movw %dx,%ax /* selector = 0x0010 = cs */ 516 movw $0x8E00,%dx /* interrupt gate - dpl=0, present */ 5172: 518 movl %eax,(%edi) 519 movl %edx,4(%edi) 520 addl $8,%edi 521 loop 2b 522 523#ifdef CONFIG_CC_STACKPROTECTOR 524 /* 525 * Configure the stack canary. The linker can't handle this by 526 * relocation. Manually set base address in stack canary 527 * segment descriptor. 528 */ 529 movl $gdt_page,%eax 530 movl $stack_canary,%ecx 531 movw %cx, 8 * GDT_ENTRY_STACK_CANARY + 2(%eax) 532 shrl $16, %ecx 533 movb %cl, 8 * GDT_ENTRY_STACK_CANARY + 4(%eax) 534 movb %ch, 8 * GDT_ENTRY_STACK_CANARY + 7(%eax) 535#endif 536 537 andl $0,setup_once_ref /* Once is enough, thanks */ 538 ret 539 540ENTRY(early_idt_handler_array) 541 # 36(%esp) %eflags 542 # 32(%esp) %cs 543 # 28(%esp) %eip 544 # 24(%rsp) error code 545 i = 0 546 .rept NUM_EXCEPTION_VECTORS 547 .ifeq (EXCEPTION_ERRCODE_MASK >> i) & 1 548 pushl $0 # Dummy error code, to make stack frame uniform 549 .endif 550 pushl $i # 20(%esp) Vector number 551 jmp early_idt_handler_common 552 i = i + 1 553 .fill early_idt_handler_array + i*EARLY_IDT_HANDLER_SIZE - ., 1, 0xcc 554 .endr 555ENDPROC(early_idt_handler_array) 556 557early_idt_handler_common: 558 /* 559 * The stack is the hardware frame, an error code or zero, and the 560 * vector number. 561 */ 562 cld 563 564 cmpl $2,(%esp) # X86_TRAP_NMI 565 je .Lis_nmi # Ignore NMI 566 567 cmpl $2,%ss:early_recursion_flag 568 je hlt_loop 569 incl %ss:early_recursion_flag 570 571 push %eax # 16(%esp) 572 push %ecx # 12(%esp) 573 push %edx # 8(%esp) 574 push %ds # 4(%esp) 575 push %es # 0(%esp) 576 movl $(__KERNEL_DS),%eax 577 movl %eax,%ds 578 movl %eax,%es 579 580 cmpl $(__KERNEL_CS),32(%esp) 581 jne 10f 582 583 leal 28(%esp),%eax # Pointer to %eip 584 call early_fixup_exception 585 andl %eax,%eax 586 jnz ex_entry /* found an exception entry */ 587 58810: 589#ifdef CONFIG_PRINTK 590 xorl %eax,%eax 591 movw %ax,2(%esp) /* clean up the segment values on some cpus */ 592 movw %ax,6(%esp) 593 movw %ax,34(%esp) 594 leal 40(%esp),%eax 595 pushl %eax /* %esp before the exception */ 596 pushl %ebx 597 pushl %ebp 598 pushl %esi 599 pushl %edi 600 movl %cr2,%eax 601 pushl %eax 602 pushl (20+6*4)(%esp) /* trapno */ 603 pushl $fault_msg 604 call printk 605#endif 606 call dump_stack 607hlt_loop: 608 hlt 609 jmp hlt_loop 610 611ex_entry: 612 pop %es 613 pop %ds 614 pop %edx 615 pop %ecx 616 pop %eax 617 decl %ss:early_recursion_flag 618.Lis_nmi: 619 addl $8,%esp /* drop vector number and error code */ 620 iret 621ENDPROC(early_idt_handler_common) 622 623/* This is the default interrupt "handler" :-) */ 624 ALIGN 625ignore_int: 626 cld 627#ifdef CONFIG_PRINTK 628 pushl %eax 629 pushl %ecx 630 pushl %edx 631 pushl %es 632 pushl %ds 633 movl $(__KERNEL_DS),%eax 634 movl %eax,%ds 635 movl %eax,%es 636 cmpl $2,early_recursion_flag 637 je hlt_loop 638 incl early_recursion_flag 639 pushl 16(%esp) 640 pushl 24(%esp) 641 pushl 32(%esp) 642 pushl 40(%esp) 643 pushl $int_msg 644 call printk 645 646 call dump_stack 647 648 addl $(5*4),%esp 649 popl %ds 650 popl %es 651 popl %edx 652 popl %ecx 653 popl %eax 654#endif 655 iret 656ENDPROC(ignore_int) 657__INITDATA 658 .align 4 659early_recursion_flag: 660 .long 0 661 662__REFDATA 663 .align 4 664ENTRY(initial_code) 665 .long i386_start_kernel 666ENTRY(setup_once_ref) 667 .long setup_once 668 669/* 670 * BSS section 671 */ 672__PAGE_ALIGNED_BSS 673 .align PAGE_SIZE 674#ifdef CONFIG_X86_PAE 675initial_pg_pmd: 676 .fill 1024*KPMDS,4,0 677#else 678ENTRY(initial_page_table) 679 .fill 1024,4,0 680#endif 681initial_pg_fixmap: 682 .fill 1024,4,0 683ENTRY(empty_zero_page) 684 .fill 4096,1,0 685ENTRY(swapper_pg_dir) 686 .fill 1024,4,0 687 688/* 689 * This starts the data section. 690 */ 691#ifdef CONFIG_X86_PAE 692__PAGE_ALIGNED_DATA 693 /* Page-aligned for the benefit of paravirt? */ 694 .align PAGE_SIZE 695ENTRY(initial_page_table) 696 .long pa(initial_pg_pmd+PGD_IDENT_ATTR),0 /* low identity map */ 697# if KPMDS == 3 698 .long pa(initial_pg_pmd+PGD_IDENT_ATTR),0 699 .long pa(initial_pg_pmd+PGD_IDENT_ATTR+0x1000),0 700 .long pa(initial_pg_pmd+PGD_IDENT_ATTR+0x2000),0 701# elif KPMDS == 2 702 .long 0,0 703 .long pa(initial_pg_pmd+PGD_IDENT_ATTR),0 704 .long pa(initial_pg_pmd+PGD_IDENT_ATTR+0x1000),0 705# elif KPMDS == 1 706 .long 0,0 707 .long 0,0 708 .long pa(initial_pg_pmd+PGD_IDENT_ATTR),0 709# else 710# error "Kernel PMDs should be 1, 2 or 3" 711# endif 712 .align PAGE_SIZE /* needs to be page-sized too */ 713#endif 714 715.data 716.balign 4 717ENTRY(stack_start) 718 .long init_thread_union+THREAD_SIZE 719 720__INITRODATA 721int_msg: 722 .asciz "Unknown interrupt or fault at: %p %p %p\n" 723 724fault_msg: 725/* fault info: */ 726 .ascii "BUG: Int %d: CR2 %p\n" 727/* regs pushed in early_idt_handler: */ 728 .ascii " EDI %p ESI %p EBP %p EBX %p\n" 729 .ascii " ESP %p ES %p DS %p\n" 730 .ascii " EDX %p ECX %p EAX %p\n" 731/* fault frame: */ 732 .ascii " vec %p err %p EIP %p CS %p flg %p\n" 733 .ascii "Stack: %p %p %p %p %p %p %p %p\n" 734 .ascii " %p %p %p %p %p %p %p %p\n" 735 .asciz " %p %p %p %p %p %p %p %p\n" 736 737#include "../../x86/xen/xen-head.S" 738 739/* 740 * The IDT and GDT 'descriptors' are a strange 48-bit object 741 * only used by the lidt and lgdt instructions. They are not 742 * like usual segment descriptors - they consist of a 16-bit 743 * segment size, and 32-bit linear address value: 744 */ 745 746 .data 747.globl boot_gdt_descr 748.globl idt_descr 749 750 ALIGN 751# early boot GDT descriptor (must use 1:1 address mapping) 752 .word 0 # 32 bit align gdt_desc.address 753boot_gdt_descr: 754 .word __BOOT_DS+7 755 .long boot_gdt - __PAGE_OFFSET 756 757 .word 0 # 32-bit align idt_desc.address 758idt_descr: 759 .word IDT_ENTRIES*8-1 # idt contains 256 entries 760 .long idt_table 761 762# boot GDT descriptor (later on used by CPU#0): 763 .word 0 # 32 bit align gdt_desc.address 764ENTRY(early_gdt_descr) 765 .word GDT_ENTRIES*8-1 766 .long gdt_page /* Overwritten for secondary CPUs */ 767 768/* 769 * The boot_gdt must mirror the equivalent in setup.S and is 770 * used only for booting. 771 */ 772 .align L1_CACHE_BYTES 773ENTRY(boot_gdt) 774 .fill GDT_ENTRY_BOOT_CS,8,0 775 .quad 0x00cf9a000000ffff /* kernel 4GB code at 0x00000000 */ 776 .quad 0x00cf92000000ffff /* kernel 4GB data at 0x00000000 */ 777