开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Linux/Unix编程 > 查看源码
head.S
资源名称：linux-2.4.20.tar.gz　[点击查看]
上传用户：jlfgdled
上传日期：2013-04-10
资源大小：33168k
文件大小：9k
源码类别：

Linux/Unix编程

开发平台：

Unix_Linux

head.S：源码内容
  1. /*
  2.  *  linux/arch/x86_64/kernel/head.S -- start in 32bit and switch to 64bit
  3.  *
  4.  *  Copyright (C) 2000 Andrea Arcangeli <andrea@suse.de> SuSE
  5.  *  Copyright (C) 2000 Pavel Machek <pavel@suse.cz>
  6.  *  Copyright (C) 2000 Karsten Keil <kkeil@suse.de>
  7.  *  Copyright (C) 2001,2002 Andi Kleen <ak@suse.de>
  8.  *
  9.  *  $Id: head.S,v 1.53 2002/07/18 09:49:42 ak Exp $
  10.  */
  13. #include <linux/linkage.h>
  14. #include <linux/threads.h>
  15. #include <asm/desc.h>
  16. #include <asm/segment.h>
  17. #include <asm/page.h>
  18. #include <asm/msr.h>
  19. #include <asm/offset.h>
  21. /* we are not able to switch in one step to the final KERNEL ADRESS SPACE
  22.  * because we need identity-mapped pages on setup so define __START_KERNEL to
  23.  * 0x100000 for this stage
  24.  * 
  25.  */
  27. .text
  28. .code32
  29. /* %bx:  1 if comming from smp trampoline on secondary cpu */ 
  30. startup_32:
  32. /*
  33.  * At this point the CPU runs in 32bit protected mode (CS.D = 1) with
  34.  * paging disabled and the point of this file is to switch to 64bit
  35.  * long mode with a kernel mapping for kerneland to jump into the
  36.  * kernel virtual addresses.
  37.    * There is no stack until we set one up.
  38.  */
  40. movl %ebx,%ebp /* Save trampoline flag */
  42. /* First check if extended functions are implemented */
  43. movl $0x80000000, %eax
  44. cpuid
  45. cmpl $0x80000000, %eax
  46. jbe no_long_mode
  47. /* Check if long mode is implemented */
  48. mov $0x80000001, %eax
  49. cpuid
  50. btl $29, %edx
  51. jnc no_long_mode
  53. movl %edx,%edi
  55. /*
  56.  * Prepare for entering 64bits mode
  57.  */
  59. /* Enable PAE mode and PGE */
  60. xorl %eax, %eax
  61. btsl $5, %eax
  62. btsl $7, %eax
  63. movl %eax, %cr4
  65. /* Setup early boot stage 4 level pagetables */
  66. movl $0x101000, %eax
  67. movl %eax, %cr3
  69. /* Setup EFER (Extended Feature Enable Register) */
  70. movl $MSR_EFER, %ecx
  71. rdmsr
  72. /* Fool rdmsr and reset %eax to avoid dependences */
  73. xorl %eax, %eax
  74. /* Enable Long Mode */
  75. btsl $_EFER_LME, %eax
  76. /* Enable System Call */
  77. btsl $_EFER_SCE, %eax
  79. #if 0
  80. /* No Execute supported? */
  81. btl $20,%edi
  82. jnc     1f
  83. btsl $_EFER_NX, %eax
  84. 1:
  85. #endif
  87. /* Make changes effective */
  88. wrmsr
  90. xorl %eax, %eax
  91. /* Enable paging and in turn activate Long Mode */
  92. btsl $31, %eax
  93. /* Enable protected mode */
  94. btsl $0, %eax
  95. /* Enable MP */
  96. btsl $1, %eax
  97. /* Enable ET */
  98. btsl $4, %eax
  99. /* Enable NE */
  100. btsl $5, %eax
  101. /* Enable WP */
  102. btsl $16, %eax
  103. /* Enable AM */
  104. btsl $18, %eax
  105. /* Make changes effective */
  106. movl %eax, %cr0
  107. jmp reach_compatibility_mode
  108. reach_compatibility_mode:
  110. /*
  111.  * At this point we're in long mode but in 32bit compatibility mode
  112.  * with EFER.LME = 1, CS.L = 0, CS.D = 1 (and in turn
  113.  * EFER.LMA = 1). Now we want to jump in 64bit mode, to do that we load
  114.  * the new gdt/idt that has __KERNEL_CS with CS.L = 1.
  115.  */
  117. testw %bp,%bp /* secondary CPU? */ 
  118. jnz   second
  120. /* Load new GDT with the 64bit segment using 32bit descriptor */
  121. /* to avoid 32bit relocations we use fixed adresses here */
  122. movl $0x100F00, %eax
  123. lgdt (%eax)
  125. movl    $0x100F10, %eax
  126. /* Finally jump in 64bit mode */
  127. ljmp *(%eax)
  129. second:
  130. /* abuse syscall to get into 64bit mode. this way we don't need
  131.    a working low identity mapping just for the short 32bit roundtrip. 
  132.    XXX kludge. this should not be needed. */
  133. movl  $MSR_STAR,%ecx
  134. xorl  %eax,%eax
  135. movl  $(__USER32_CS<<16)|__KERNEL_CS,%edx
  136. wrmsr
  138. movl  $MSR_CSTAR,%ecx
  139. movl  $0xffffffff,%edx
  140. movl  $0x80100100,%eax # reach_long64 absolute
  141. wrmsr
  142. syscall
  144. .code64
  145. .org 0x100
  146. reach_long64:
  147. movq init_rsp(%rip),%rsp
  149. /* zero EFLAGS after setting rsp */
  150. pushq $0
  151. popfq
  153. /*
  154.  * We must switch to a new descriptor in kernel space for the GDT
  155.  * because soon the kernel won't have access anymore to the userspace
  156.  * addresses where we're currently running on. We have to do that here
  157.  * because in 32bit we couldn't load a 64bit linear address.
  158.  */
  159. lgdt pGDT64
  161. /* 
  162.  * Setup up a dummy PDA. this is just for some early bootup code
  163.  * that does in_interrupt() 
  164.  */ 
  165. movl $MSR_GS_BASE,%ecx
  166. movq $cpu_pda,%rax
  167. movq    %rax,%rdx
  168. shrq $32,%rdx
  169. wrmsr
  171. /* set up data segments. actually 0 would do too */
  172. movl $__KERNEL_DS,%eax
  173. movl %eax,%ds
  174. movl %eax,%ss
  175. movl %eax,%es
  177. /* esi is pointer to real mode structure with interesting info.
  178.    pass it to C */
  179. movl %esi, %edi
  181. /* Finally jump to run C code and to be on real kernel address
  182.  * Since we are running on identity-mapped space we have to jump
  183.  * to the full 64bit address , this is only possible as indirect
  184.  * jump
  185.  */
  186. movq initial_code(%rip),%rax
  187. jmp *%rax
  189. /* SMP bootup changes these two */
  190. .globl initial_code
  191. initial_code:
  192. .quad x86_64_start_kernel
  193. .globl init_rsp
  194. init_rsp:
  195. .quad  init_task_union+THREAD_SIZE-8
  198. .code32
  199. ENTRY(no_long_mode)
  200. /* This isn't an x86-64 CPU so hang */
  201. 1:
  202. jmp 1b
  204. .org 0xf00
  205. pGDT32:
  206. .word gdt32_end-gdt_table32
  207. .long gdt_table32-__START_KERNEL+0x100000
  209. .org 0xf10
  210. ljumpvector:
  211. .long reach_long64-__START_KERNEL+0x100000
  212. .word __KERNEL_CS
  214. ENTRY(stext)
  215. ENTRY(_stext)
  217. /*
  218.  * This default setting generates an ident mapping at address 0x100000
  219.  * and a mapping for the kernel that precisely maps virtual address
  220.  * 0xffffffff80000000 to physical address 0x000000. (always using
  221.  * 2Mbyte large pages provided by PAE mode)
  222.  */
  223. .org 0x1000
  224. ENTRY(init_level4_pgt)
  225. .quad 0x0000000000102007 /* -> level3_ident_pgt */
  226. .fill 255,8,0
  227. .quad 0x000000000010a007
  228. .fill 254,8,0
  229. /* (2^48-(2*1024*1024*1024))/(2^39) = 511 */
  230. .quad 0x0000000000103007 /* -> level3_kernel_pgt */
  232. .org 0x2000
  233. /* Kernel does not "know" about 4-th level of page tables. */
  234. ENTRY(level3_ident_pgt)
  235. .quad 0x0000000000104007
  236. .fill 511,8,0
  238. .org 0x3000
  239. ENTRY(level3_kernel_pgt)
  240. .fill 510,8,0
  241. /* (2^48-(2*1024*1024*1024)-((2^39)*511))/(2^30) = 510 */
  242. .quad 0x0000000000105007 /* -> level2_kernel_pgt */
  243. .fill 1,8,0
  245. .org 0x4000
  246. ENTRY(level2_ident_pgt)
  247. /* 40MB for bootup.  */
  248. .quad 0x0000000000000283
  249. .quad 0x0000000000200183
  250. .quad 0x0000000000400183
  251. .quad 0x0000000000600183
  252. .quad 0x0000000000800183
  253. .quad 0x0000000000A00183
  254. .quad 0x0000000000C00183
  255. .quad 0x0000000000E00183
  256. .quad 0x0000000001000183
  257. .quad 0x0000000001200183
  258. .quad 0x0000000001400183
  259. .quad 0x0000000001600183
  260. .quad 0x0000000001800183
  261. .quad 0x0000000001A00183
  262. .quad 0x0000000001C00183
  263. .quad 0x0000000001E00183
  264. .quad 0x0000000002000183
  265. .quad 0x0000000002200183
  266. .quad 0x0000000002400183
  267. .quad 0x0000000002600183
  268. /* Temporary mappings for the super early allocator in arch/x86_64/mm/init.c */
  269. .globl temp_boot_pmds
  270. temp_boot_pmds:
  271. .fill 492,8,0
  273. .org 0x5000
  274. ENTRY(level2_kernel_pgt)
  275. /* 40MB kernel mapping. The kernel code cannot be bigger than that.
  276.    When you change this change KERNEL_TEXT_SIZE in pgtable.h too. */
  277. /* (2^48-(2*1024*1024*1024)-((2^39)*511)-((2^30)*510)) = 0 */
  278. .quad 0x0000000000000183
  279. .quad 0x0000000000200183
  280. .quad 0x0000000000400183
  281. .quad 0x0000000000600183
  282. .quad 0x0000000000800183
  283. .quad 0x0000000000A00183
  284. .quad 0x0000000000C00183
  285. .quad 0x0000000000E00183
  286. .quad 0x0000000001000183
  287. .quad 0x0000000001200183
  288. .quad 0x0000000001400183
  289. .quad 0x0000000001600183
  290. .quad 0x0000000001800183
  291. .quad 0x0000000001A00183
  292. .quad 0x0000000001C00183
  293. .quad 0x0000000001E00183
  294. .quad 0x0000000002000183
  295. .quad 0x0000000002200183
  296. .quad 0x0000000002400183
  297. .quad 0x0000000002600183
  298. /* Module mapping starts here */
  299. .fill 492,8,0
  301. .org 0x6000
  302. ENTRY(empty_zero_page)
  304. .org 0x7000
  305. ENTRY(empty_bad_page)
  307. .org 0x8000
  308. ENTRY(empty_bad_pte_table)
  310. .org 0x9000
  311. ENTRY(empty_bad_pmd_table)
  313. .org 0xa000
  314. ENTRY(level3_physmem_pgt)
  315. .quad 0x0000000000105007 /* -> level2_kernel_pgt (so that __va works even before pagetable_init) */
  317. .org 0xb000
  318. .data
  320. .globl SYMBOL_NAME(gdt)
  322. .word 0
  323. .align 16
  324. .word 0
  325. pGDT64:
  326. .word gdt_end-gdt_table
  327. SYMBOL_NAME_LABEL(gdt)
  328. .quad gdt_table
  331. .align 64 /* cacheline aligned */
  332. ENTRY(gdt_table32)
  333. .quad 0x0000000000000000 /* This one is magic */
  334. .quad 0x0000000000000000 /* unused */
  335. .quad 0x00af9a000000ffff /* __KERNEL_CS */
  336. gdt32_end:
  338. /* We need valid kernel segments for data and code in long mode too
  339.  * IRET will check the segment types  kkeil 2000/10/28
  340.  * Also sysret mandates a special GDT layout 
  341.  */
  342.  
  343. .align 64 /* cacheline aligned, keep this synchronized with asm/desc.h */
  344. ENTRY(gdt_table)
  345. .quad 0x0000000000000000 /* This one is magic */
  346. .quad 0x0000000000000000 /* unused */
  347. .quad 0x00af9a000000ffff /* __KERNEL_CS */
  348. .quad 0x00cf92000000ffff /* __KERNEL_DS */
  349. .quad 0x00cffe000000ffff /* __USER32_CS */
  350. .quad 0x00cff2000000ffff /* __USER_DS, __USER32_DS  */
  351. .quad 0x00affa000000ffff /* __USER_CS */
  352. .word 0xFFFF # 4Gb - (0x100000*0x1000 = 4Gb)
  353. .word 0 # base address = 0
  354. .word 0x9A00 # code read/exec
  355. .word 0x00CF # granularity = 4096, 386
  356. #  (+5th nibble of limit)
  357. /* __KERNEL32_CS */
  358. /* when you add something here fix constant in desc.h */
  359. .globl gdt_cpu_table
  360. gdt_cpu_table:
  361. .fill NR_CPUS*PER_CPU_GDT_SIZE,1,0
  362. gdt_end:
  363. .globl gdt_end
  365. .align  64
  366. ENTRY(idt_table)
  367. .rept   256
  368. .quad   0
  369. .quad  0
  370. .endr