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