kolibri 汇编代码学习研究

不点 · 发表于 2014-11-14 11:54:47

本帖最后由不点于 2014-11-30 15:02 编辑

最近看了 kolibri 的代码，觉得是个很不错的操作系统学习资料。我准备贴出自己的学习心得，和开发者朋友们分享。如果我理解有错误，希望开发者们能帮助纠正。

请不要发表与技术无关的言论，冲淡这个话题。请版主们给以支持，删除那些与技术无关的帖子。

修改记录：

2014-11-30 添加了虚拟地址映射，将物理地址 0 至 4M 的空间映射为虚拟地址 0xC0000000 处的 4M 空间，方便读写实模式内存。
2014-11-29 添加了实模式处理代码，可以正常重启，重启时不再死机了。
2014-11-28 屏蔽掉 intel 深度休眠代码，避免进入实模式引起启动失败。
2014-11-27 成功进入桌面，只是在点击重启时会死机。原因是重启时要使用实模式，而我们的实模式代码位于扩展内存，没有拷贝到常规内存，所以就死机了。其实关机也有可能死机，这种情况发生在那些必须使用 BIOS 来关机的电脑上。这是小问题，目前我们没必要处理这些问题，因为将来会统一处理实模式与保护模式切换的问题。

不点 · 发表于 2014-11-14 12:11:05

本帖最后由不点于 2014-11-15 08:15 编辑

kolibri 的 32 位启动代码是这样的：

; CR0 Flags - Protected mode and Paging
mov ecx, CR0_PE
; Enabling 32 bit protected mode
sidt [cs:old_ints_h]
cli ; disable all irqs
cld
mov al, 255 ; mask all irqs
out 0xa1, al
out 0x21, al

复制代码

首先是用 sidt 指令保存实模式的中断描述符表寄存器到内存地址 cs:old_ints_h。将来要进入实模式时，还要用到这个寄存器值。从它的 bootloader 代码可以分析得到，kolibri 的内核被加载在 1000:0000 处。所以，刚才提到的内存地址大致也在这个位置以上的常规内存空间中。

紧接着是屏蔽硬件中断。

接下来是 enable A20，就不贴了。

之后，是下面这段，装入 GDT，进入 32 位保护模式：

lgdt [cs:tmp_gdt] ; Load GDT
mov eax, cr0 ; protected mode
or eax, ecx
and eax, 10011111b *65536*256 + 0xffffff ; caching enabled
mov cr0, eax
jmp pword os_code:B32 ; jmp to enable 32 bit mode
align 8
tmp_gdt:
dw 23
dd tmp_gdt+0x10000
dw 0
dw 0xffff
dw 0x0000
db 0x00
dw 11011111b *256 +10011010b
db 0x00
dw 0xffff
dw 0x0000
db 0x00
dw 11011111b *256 +10010010b
db 0x00

复制代码

它的 GDT 表没有注释，所以，需要弄清楚它的含义。

两个 GDT 表项的段限都是 limit=0xFFFFF 即，1M，粒度都是 4K，说明实际上是 4G 的段限。基地址都是 base=0。

第一个是代码段，第二个是数据段。

补充: GDT 表 align 8 是不行的，linux 内核早有注释，说应该使用 align 16.

不点 · 发表于 2014-11-14 17:10:14

这一段，设置保护模式堆栈。

B32:
mov ax, os_stack ; Selector for os
mov ds, ax
mov es, ax
mov fs, ax
mov gs, ax
mov ss, ax
mov esp, 0x006CC00 ; Set stack

复制代码

堆栈位于常规内存空间范围内。

不点 · 发表于 2014-11-14 17:19:20

这一段，清除内存软盘结尾处 0x280000 至堆内存基地址（位于物理地址 8M 处）之间的内存。

; CLEAR 0x280000 - HEAP_BASE
xor eax, eax
mov edi, CLEAN_ZONE
mov ecx, (HEAP_BASE-OS_BASE-CLEAN_ZONE) / 4
cld
rep stosd

复制代码

不点 · 发表于 2014-11-14 17:29:38

本帖最后由不点于 2014-11-14 17:48 编辑

这一段，清除内核未初始化的全局变量。

; CLEAR KERNEL UNDEFINED GLOBALS
mov edi, endofcode-OS_BASE
mov ecx, 0x90000
sub ecx, edi
shr ecx, 2
rep stosd

复制代码

edi 指向 code 结尾处，从此处到 9000:0000 的内存被清除。前面已经看到，堆栈也在这个范围之内。这应该是没问题的，因为此时堆栈还没有开始使用，比如，没有使用 push，pop，call，ret，int，iret 等指令。

补充：这个清理并不十分安全。清理到 8000:0000 是安全的。有些 PXE bios 使用了 8000:0000 以上的空间，如果这个空间被清除，那以后如果使用 BIOS 就会死机了。最安全的做法是使用 BIOS 数据区 0x413 处的值来决定应该清理的内存量。

不点 · 发表于 2014-11-14 17:42:12

这一段，是清除最开头的 64K 物理内存。当然，最开头的 4K 页面是不可以清除的，因为 BIOS 要用它。位于 0000:9000 的 4K 也保留，未被清除，可能内核要用它。

; SAVE & CLEAR 0-0xffff
mov edi, 0x1000
mov ecx, 0x8000 / 4
rep stosd
mov edi, 0xa000
mov ecx, 0x6000 / 4
rep stosd

复制代码

内核就位于 1000:0000 处，也就是位于第一个 64K 空间的结尾处。

不点 · 发表于 2014-11-15 07:56:29

本帖最后由不点于 2014-11-15 08:09 编辑

接下来这几个函数都在 init.inc 文件中。

call test_cpu
bts [cpu_caps-OS_BASE], CAPS_TSC ;force use rdtsc
call check_acpi
call init_BIOS32
; MEMORY MODEL
call mem_test
call init_mem
call init_page_map

复制代码

本楼留着以后讨论其中某些部分。

不点 · 发表于 2014-11-15 08:22:54

本帖最后由不点于 2014-11-25 10:12 编辑

memmap.inc 是一个说明文件，列出了内存使用情况。其中实模式启动部分所使用的内存如下:

; Boot:
;
; 0:9000 byte bits per pixel
; 0:9001 word scanline length
; 0:9008 word vesa video mode
; 0:900A word X res
; 0:900C word Y res
; 0:9010 byte mouse port - not used
; 0:9014 dword Vesa 1.2 pm bank switch
; 0:9018 dword Vesa 2.0 LFB address
; 0:901C byte 0 or 1 : enable MTRR graphics acceleration
; 0:901D byte not used anymore (0 or 1 : enable system log display)
; 0:901E byte 0 or 1 : enable direct lfb write, paging disabled
; 0:901F byte DMA write : 1=yes, 2=no
; 0:9020 8bytes pci data
; 0:9030 byte VRR start enabled 1, 2-no
; 0:9031 word IDEContrRegsBaseAddr
; 0x9040 - dword - entry point of APM BIOS
; 0x9044 - word - version (BCD)
; 0x9046 - word - flags
; 0:907F byte number of BIOS hard disks
; 0:9080 Nbytes BIOS hard disks
; 0:9100 word available physical memory map: number of blocks
; 0:9104 available physical memory map: blocks
;

复制代码

保护模式使用的内存如下：

; 0x00000000 -> 0x7FFFFFFF application 2Gb
; 0x80000000 -> 0FFF physical page zero - do not write
; (used by int 13h in some configurations)
;
; 0x80001000 -> 2FFF window_data - 256 entries
;
; 0000 dword x start
; 0004 dword y start
; 0008 dword x size
; 000C dword y size
; 0010 dword color of work area
; 0014 dword color of grab bar
; 0018 dword color of frames
; 001C dword window flags, +30 = window drawn, +31 redraw flag
;
; 3000 -> 4FFF task list - 256 entries
;
; 00 dword process count
; 04 dword no of processes
; 10 dword base of running process at 0x3000+
;
; 20 dword application event mask
; 24 dword PID - process identification number
; 2a byte slot state: 0=running, 1,2=suspended
; 3=zombie, 4=terminate,
; 5=waiting for event, 9 = not used
; 2e byte window number on screen
; 30 dword exact position in memory
; 34 dword counter sum
; 38 dword time stamp counter add
; 3c dword cpu usage in cpu timer tics
;
;
; 5000 -> 68FF free (6k6)
; 6900 -> 6EFF saved picture under mouse pointer (1k5)
;
; 6F00 -> 6FFF free (256)
;
; 7000 -> 7FFF used CD driver
;
; 8000 -> A3FF used FLOPPY driver
;
; A400 -> B0FF free (3k3), unused ACTIVE_PROC_STACK
; B100 -> B307 IDT for int_0x00..int_0x40
; B308 -> BFFF free (3k3)
; C000 -> C3FF window stack C000 no of windows - all in words
; C402 -> C7FF window position in stack
; D000 -> D1FF FDC controller
; D200 -> D3FF FDC controller for Fat12
; D400 -> DFFF free (3k)
; E000 byte multitasking started
; E020 dword putpixel address
; E024 dword getpixel address
; E030 dword Vesa 1.2 pm bank switch address
; E034 -> F1FF free (4k5)
; F200 dword mousepicture -pointer
; F204 dword mouse appearance counter
; F208 -> F2FF free (248)
; F300 dword x & y temp for windowmove
; F304 -> F3FF free (252)
; F400 byte no of keys in buffer
; F401 byte 'buffer'
; F402 -> F4FF reserved for keys
; F500 byte no of buttons in buffer
; F501 dword 'buffer'
; F502 -> F5FF reserved for buttons
; F600 dword tsc / second
; F604 byte (unused?) mouse port: 1 ps2, 2 com1, 3 com2
; F605 -> FAFF free (1k2)
; FB00 -> FB0F mouse memory 00 chunk count, that includes:
; FB08 word -- mouse H-scroll
; FB0A word -- mouse x
; FB0C word -- mouse y
; FB0E word -- mouse V-scroll
; FB10 -> FB17 mouse color mem
; FB21 x move
; FB22 y move
; FB28 high bits temp
; FB30 color temp
; FB40 byte buttons down
; FB44 byte 0 mouse down -> do not draw
; FB4A -> FB4D FB4A-B x-under - FB4C-D y-under
; FBF1 byte bits per pixel
; FC00 -> FCFE com1/ps2 buffer
; FCFF com1/ps2 buffer count starting from FC00
; FD00 -> FDFF free (256)
; FE00 dword screen x size
; FE04 dword screen y size
; FE08 dword screen y multiplier
; FE0C dword screen mode
; FE10 -> FE7F free (112)
; FE80 dword address of LFB in physical
; FE84 dword address of applications memory start in physical ?
; FE88 dword address of button list
; FE8C dword memory to use
; FE90 -> FEFF free (112)
; FF00 byte 1 = system shutdown request
; FF01 byte task activation request?
; FFF0 byte >0 if redraw background request from app
; FFF1 byte free
; FFF2 write and read bank in screen
; FFF4 byte 0 if first mouse draw & do not return picture under
; FFF5 byte 1 do not draw pointer
; FFFF byte do not change task for 1/100 sec.
;
; 0x80010000 -> 6CBFF kernel, 32-bit run-time code (up to 371 Kb)
; 0x8006CC00 -> 6DBFF stack at boot time (4Kb)
;
; 0x8006DC00 -> 6E5FF free (2560)
; 0x8006E600 -> 6Efff free (2560)
; 0x8006F000 -> 6FFFF main page directory
; 0x80070000 -> 7FFFF data of retrieved disks and partitions (Mario79)
; 0x80080000 -> 8FFFF additional app info, in 256 byte steps - 256 entries
;
; 00 11db name of app running
; 0x10 dword pointer to fpu save area
; 0x14 dword event count
; 0x18 dword user fpu exceptoins handler
; 0x1c dword user sse exceptions handler
; 20 dword PL0 stack base
; 24 dword user heap base
; 28 dword user heap top
; 2c dword window cursor handle
; 30 dword first event in list
; 34 dword last event in list
; 38 dword first kernel object in list
; 3c dword last kernel object in list
; 40 dword thread esp
; 44 dword io permission map page 0
; 48 dword io permission map page 1
; 4c dword debug state: 1= load debug registers
; 50 dword current directory ptr
; 54 dword wait timeout
; 58 dword thread TSS._esp0 (= pl0 stack base + size except for V86)
; 5C-7F unused
;
; 80 dword address of random shaped window area
; 84 byte shape area scale
; 88 dword free
; 8C dword application memory size
; 90 dword window X position save
; 94 dword window Y position save
; 98 dword window X size save
; 9C dword window Y size save
; A0 dword IPC memory start
; A4 dword IPC memory size
; A8 dword event bits: mouse, stack,..
; AC dword 0 or debugger slot
; B0 dword free
; B4 byte keyboard mode: 0 = keymap, 1 = scancodes
; B8 dword physical address of directory table
; BC dword address of debug event memory
; C0 5 dd thread debug registers: DR0,DR1,DR2,DR3,DR7
;
; 0x80090000 -> 9FFFF tmp (64k) - unused?
; 0x800A0000 -> AFFFF screen access area
; 0x800B0000 -> FFFFF bios rest in peace -area (320k) ?
; 0x80100000 -> 27FFFF diskette image (1m5)
; 0x80280000 -> 283FFF free (16k)
;
; 0x80284000 -> 28BFFF HDD DMA AREA (32k)
; 0x8028C000 -> 297FFF free (48k)
;
; 0x80298000 -> 29FFFF auxiliary table for background smoothing code (32k)
;
; 0x802A0000 -> 2B00FF wav device buffer (64k)
; 0x802A0000 -> 2B00FF wav device status (256)
;
; 0x802B0100 -> 2B3FFD free (15k7)
;
; 0x802B3FEE -> 2B3FEF button info (64K+ 16 + 2 byte)
; 2B3FEE 0000 word number of buttons
; 2B3FF0 first button entry
;
; button entry at 0x10
; +0000 word process number
; +0002 word button id number : bits 00-15
; +0004 word x start
; +0006 word x size
; +0008 word y start
; +000A word y size
; +000C word button id number : bits 16-31
;
; 0x802C4000 -> 2C9FFF area for fast getting offset to LFB (24k)
; BPSLine_calc_area
; 0x802CA000 -> 2CFFFF area for fast getting offset to _WinMapAddress (24k)
; d_width_calc_area
;
; 0x802D0000 -> 2DFFFF reserved port area (64k)
;
; 0000 dword no of port areas reserved
; 0010 dword process id
; dword start port
; dword end port
; dword 0
;
; 0x802E0000 -> 2EFFFF irq data area (64k) ;BOOT_VAR
;
; 0x802F0000 -> 2F3FFF tcp memory stack_data_start eth_data_start (16k)
;
; 0x802F4000 -> 30ffff stack_data | stack_data_end (112k)
;
; 0x80310000 -> 317fff resendQ (32k)
;
; 0x80318000 -> 31ffff skin_data (32k)
;
; 0x80320000 -> 323FF3 draw data - 256 entries (4k)
; 00 dword draw limit - x start
; 04 dword draw limit - y start
; 08 dword draw limit - x end
; 0C dword draw limit - y end
;
; 0x8032BFF4 -> 32BFFF background info
; 0x80323FF4 BgrDrawMode
; 0x80323FF8 BgrDataWidth
; 0x80323FFC BgrDataHeight
;
; 0x80324000 page map (length b = memsize shr 15)
; 0x80324000 + b start of static pagetables
; 0x803FFFFF <- no direct address translation beyond this point
; =============================================================
; 0x805FF000 -> 5FFF80 TSS
; 0x80600000 -> 601FFF i/o maps
; 0x80800000 -> kernel heap
; 0x80FFFFFF heap min limit
; 0xFDBFFFFF heap max limit
; 0xF0000000 -> 0xF1FFFFFF PCI-express extended config space
; 0xFDC00000 -> 0xFDFFFFFF page tables 4Mb
; 0xFE000000 -> 0xFFFFFFFF LFB 32Mb
; 0xFE000000 -> 0xFE7FFFFF application available LFB 8Mb
; 0xFE800000 -> 0xFFFFFFFF kernel LFB part 24 Mb

复制代码

不点 · 发表于 2014-11-15 08:43:50

本帖最后由不点于 2014-11-25 11:30 编辑

init_mem 函数很重要，一字一句详细分析一下。

align 4
proc init_mem
; calculate maximum allocatable address and number of allocatable pages
mov edi, BOOT_VARS-OS_BASE + 0x9104 ; 从 0000:9104 开始，记录的是可用内存块的数组。
mov ecx, [edi-4] ; 而 0000:9100 处的四字节记录了可用内存块的个数。
xor esi, esi; esi will hold total amount of memory
xor edx, edx; edx will hold maximum allocatable address
.calcmax:
; round all to pages
mov eax, [edi] ; 取内存块起始地址到 eax
cmp [edi+16], byte 1 ; 检查内存块类型是否是可用内存
jne .unusable ; 不是可用内存，跳过
test eax, 0xFFF ; 检查起始地址是否为页面对齐
jz @f ; 是的，跳过
neg eax ; 不是按页对齐,取反它
and eax, 0xFFF ; 屏蔽掉高位，只留下余数
add [edi], eax ; 把它加到内存起始地址上，让其变成页面对齐
adc dword [edi+4], 0 ; 进位时，调整高 32 位值
sub [edi+8], eax ; 相应地，内存块长度也要适当减少
sbb dword [edi+12], 0 ; 借位时，调整高 32 位的值
jc .unusable ; 万一不够减，说明它太小，就忽略这块内存
@@:
and dword [edi+8], not 0xFFF ; 割掉内存块长度的尾巴, 让其 4K 对齐
jz .unusable ; 割掉以后长度为 0, 无用了，忽略这块内存
; ignore memory after 4 Gb
cmp dword [edi+4], 0 ; 起始地址高 32 位是否为 0?
jnz .unusable ; 不是 0, 说明位于 4G 以上，忽略这块内存
mov eax, [edi] ; 内存块起始于 4G 以内，取其起始地址到 eax
cmp dword [edi+12], 0 ; 内存块长度高 32 位是否为 0?
jnz .overflow ; 不是 0, 说明长度超过 4G, 需要截短
add eax, [edi+8] ; 长度不超过 4G, 加到 eax 上，得到内存块的尾端地址
jnc @f ; 没有发生进位，不用截短
.overflow:
mov eax, 0xFFFFF000 ; 截短, 尾部使用最高地址减去 4K
@@:
cmp edx, eax ; edx 比尾部地址大吗?
jae @f ; 已经够大，跳过
mov edx, eax ; 不够大，让其取当前最大的尾部地址值
@@:
sub eax, [edi] ; 尾部地址减去起始地址，等于内存块长度
mov [edi+8], eax ; 修正长度低 32 位，但高 32 位也应该清 0, 却忘记了!
add esi, eax ; 累加到 esi, 记录 4G 以内的全部可用内存量。
jmp .usable
.unusable:
; and dword [edi+8], 0
.usable:
add edi, 20 ; 处理下一个内存块
loop .calcmax ; 循环计算最大值
.calculated: ; 最大值计算完成，保存可用内存量到两个地址处
mov [MEM_AMOUNT-OS_BASE], esi ; 可用内存量记录在地址 0xFE8C 处
mov [pg_data.mem_amount-OS_BASE], esi
shr esi, 12 ; 变成页面个数, 加以保存
mov [pg_data.pages_count-OS_BASE], esi
shr edx, 12 ; 把最高尾端地址也转化为页面值
add edx, 31 ; 加上尾巴, 准备按 32 对齐
and edx, not 31 ; 割掉尾巴
shr edx, 3 ; 右移 3 位，就是除以 8, 理解不了----这可能是个错误。假如不是错误的话，那就是把每个页面对应于一个 bit，8 个页面就对应于一个字节，所以要除以 8，得到页映射位图所需要的字节数。
mov [pg_data.pagemap_size-OS_BASE], edx
add edx, (sys_pgmap-OS_BASE)+4095 ; 从系统页映射（应该是位图）基地址开始，加上页映射位图所需要的字节数
and edx, not 4095 ; 再向上进行页对齐
mov [tmp_page_tabs], edx ; 就得到了下一个临时页表的基地址。
mov edx, esi ; 取可用页面的总数
and edx, -1024 ; 向下页对齐
cmp edx, (OS_BASE/4096) ; 比用户程序虚拟内存页数多吗?
jbe @F ; 不多，跳过
mov edx, (OS_BASE/4096) ; 多了，截短, 只使用所需要的页数
jmp .set
@@:
cmp edx, (HEAP_BASE-OS_BASE+HEAP_MIN_SIZE)/4096 ; 比内核所需要的页数少吗? HEAP_BASE位于8M处，HEAP_MIN_SIZE=16M
jae .set ; 不少，跳过
mov edx, (HEAP_BASE-OS_BASE+HEAP_MIN_SIZE)/4096 ; 少了，扩大到内核所需要的页面数
.set:
mov [pg_data.kernel_pages-OS_BASE], edx ; 这就得到了内核要处理的页面总数
页面总容量的范围是 24M 至 2G。
shr edx, 10 ; 每个页表可以含有 1024 个页面指针，所以，除以 1024
mov [pg_data.kernel_tables-OS_BASE], edx ; 得到内核所需要的页表数。
每个页表对应于 4M 空间，所以，最多只有 512 个页表。
; 清除内核进程空间 8K，页目录被清零。
xor eax, eax
mov edi, sys_proc-OS_BASE ; EDI=0x6F000
mov ecx, 8192/4
cld
rep stosd
mov edx, (sys_proc-OS_BASE+PROC.pdt_0)+ 0x800; (OS_BASE shr 20) 指向 kernel 所对应的页目录项
bt [cpu_caps-OS_BASE], CAPS_PSE ; CPU 支持页面大小扩展吗？
jnc .no_PSE ; 不支持，跳过
mov ebx, cr4
or ebx, CR4_PSE
mov eax, PG_LARGE+PG_SW ; 页目录项直接使用 4M 的大页面
mov cr4, ebx ; 开启页面大小扩展功能
dec [pg_data.kernel_tables-OS_BASE] ; 内核页表个数减少 1 个
mov [edx], eax ; 写入第一个页目录项，指向物理地址 0 处的 4M 空间。
add edx, 4 ; 这是下一个页目录项的指针
mov edi, [tmp_page_tabs]
jmp .map_kernel_heap ; new kernel fits to the first 4Mb - nothing to do with ".map_low"
.no_PSE:
先填充临时页表，它包含了从物理地址0到tmp_page_tabs的全部页
tmp_page_tabs 大约位于 0x344000，那么，总共的页数就是 0x344 个。
mov eax, PG_SW
mov ecx, [tmp_page_tabs]
shr ecx, 12
.map_low:
mov edi, [tmp_page_tabs]
@@: ;
stosd
add eax, 0x1000
dec ecx
jnz @B
0x344 个指针的长度是 0x344 × 4 = 0xD10 = 3344 字节。
写完临时页表之后，紧接着是内核页表。
.map_kernel_heap:
首先清空内核页表，它最大有 2M 的长度。
mov ecx, [pg_data.kernel_tables-OS_BASE]
shl ecx, 10
xor eax, eax
rep stosd
开始写内核页目录项，指向临时页表，在 PSE 的情况，它是指向清空了的内核页表；
在 no_PSE 的情况，它是指向临时页表，最终映射到物理地址 0。
这里比较混乱。在 PSE 的情况，4M 是已经完全映射的。而在 no_PSE 的情况，4M 没有完全映射。
mov ecx, [pg_data.kernel_tables-OS_BASE]
mov eax, [tmp_page_tabs]
or eax, PG_SW
mov edi, edx
.map_kernel_tabs:
stosd
add eax, 0x1000
dec ecx
jnz .map_kernel_tabs
内核页目录项写完了，再把页目录所在的地址映射到 page_tabs 处。
mov dword [sys_proc-OS_BASE+PROC.pdt_0+(page_tabs shr 20)], sys_proc+PROC.pdt_0+PG_SW-OS_BASE
mov edi, (sys_proc+PROC.pdt_0-OS_BASE)
lea esi, [edi+(OS_BASE shr 20)]
movsd
movsd
ret
endp

复制代码

不点 · 发表于 2014-11-22 02:05:47

本帖最后由不点于 2014-11-25 15:51 编辑

proc init_page_map
; mark all memory as unavailable 先把所有的内存标为 "不可用"。
mov edi, sys_pgmap-OS_BASE 准备写系统页位图
mov ecx, [pg_data.pagemap_size-OS_BASE] 取页位图的长度
shr ecx, 2 转换成 dword 的个数
xor eax, eax 写入 0
cld
rep stosd
扫描内存图，将自由区域标为 "可用"
; scan through memory map and mark free areas as available
mov ebx, BOOT_VARS-OS_BASE + 0x9104 取内存块基地址
mov edx, [ebx-4] 取内存块个数
.scanmap:
cmp [ebx+16], byte 1 是自由内存吗？
jne .next 不是的，忽略
mov ecx, [ebx+8] 取内存块长度
shr ecx, 12; ecx = number of pages 转换成页数
jz .next 是0，跳过
mov edi, [ebx] 取内存块基地址
shr edi, 12; edi = first page 转换成页序号
mov eax, edi
shr edi, 5 除以 32
shl edi, 2 乘4，得到字节偏移
add edi, sys_pgmap-OS_BASE 得到要修改的字节指针
and eax, 31 得到余数
jz .startok 如果余数是0，跳过
add ecx, eax
sub ecx, 32
jbe .onedword 只有 1 个 dword 宽
push ecx
mov ecx, eax 先处理余数，保存在 ecx 中
or eax, -1 此时 EAX=FFFFFFFF
shl eax, cl
or [edi], eax 把开头的余数部分处理完毕，剩下是 dword 对齐的了
add edi, 4 下一个 dword
pop ecx
.startok:
push ecx
shr ecx, 5 页数除以 32
or eax, -1 每次标注 32 个页为可用页
rep stosd
pop ecx
and ecx, 31 余数
neg eax 此时 EAX=1
shl eax, cl
dec eax
or [edi], eax 所有的余数页都处理完毕
jmp .next
.onedword:
add ecx, 32
sub ecx, eax
@@:
bts [edi], eax
inc eax
loop @b
.next:
add ebx, 20
dec edx
jnz .scanmap
; mark kernel memory as allocated (unavailable) 把内核的内存标为不可用
mov ecx, [tmp_page_tabs] 内核代码数据尾端地址
mov edx, [pg_data.pages_count-OS_BASE] 总页数
shr ecx, 12 内核代码数据占用的页数
add ecx, [pg_data.kernel_tables-OS_BASE] 再加上内核要处理的页表数，得到内核保留的页数
sub edx, ecx 总页数减去内核保留的页数，得到自由页数
mov [pg_data.pages_free-OS_BASE], edx 保存自由页数
mov edi, sys_pgmap-OS_BASE
mov ebx, ecx 内核保留的页数
shr ecx, 5
xor eax, eax 设定为不可用
rep stosd
not eax
mov ecx, ebx
and ecx, 31 余数部分
shl eax, cl
and [edi], eax 处理完毕
add edi, OS_BASE
mov [page_start-OS_BASE], edi; 页位图的自由页起始地址保存在 page_start 变量中
mov ebx, sys_pgmap 页位图起始地址
add ebx, [pg_data.pagemap_size-OS_BASE] 加上页位图的长度
mov [page_end-OS_BASE], ebx 页位图的终止地址，保存在 page_end 中。
ret
endp

复制代码

不点 · 发表于 2014-11-23 22:23:03

本帖最后由不点于 2014-11-24 10:13 编辑

尝试修改了一下，制作了补丁，在一楼下载。

编译生成 kernel.mnt 文件，这就是 kolibri 的内核。

用它替换掉 kolibri.img 里面的同名文件，即可测试了。

目前 USB 初始化部分有问题。进入桌面后，不能用鼠标。

总之，排错的工作量很大。

不点 · 发表于 2014-11-29 10:08:53

本帖最后由不点于 2014-11-29 10:13 编辑

整理一下 grub4dos 的分页数据结构。

/* Paging structure : PML4, PDPT, PD  4096-bytes each */
/* Memory area from 0x50000 to the end of low memory is used by gfxmenu. So we
* should not use 0x60000 for page tables. And all other free room in the low
* memory is reserved. So we should use extended memory if possible.
* Currently we use the ending 16K of the first 16M. -- tinybit
*
* Big problem! Some chipset use 1M at 15M. -- tinybit 2012-11-01
*/

//#define PAGING_TABLES_BUF       0x60000
//#define PAGING_TABLES_BUF       0xFFC000
#define PAGING_TABLES_BUF       0xEFC000
#define PAGING_TABLES_BUFLEN       0x4000

以下是 char_io.c 里面关于分页的代码。

#define PAGING_PML4_ADDR (PAGING_TABLES_BUF+0x0000)
#define PAGING_PDPT_ADDR (PAGING_TABLES_BUF+0x1000)
#define PAGING_PD_ADDR (PAGING_TABLES_BUF+0x2000)

// If this value is changed, memory_paging_map_for_transfer must also be modified.
#define PAGINGTXSTEP 0x800000

#define DST_VIRTUAL_BASE  0x1000000UL
#define SRC_VIRTUAL_BASE  0x2000000UL
#define DST_VIRTUAL_ADDR(addr) (((unsigned long)(addr) & 0x1FFFFFUL)+DST_VIRTUAL_BASE)
#define SRC_VIRTUAL_ADDR(addr) (((unsigned long)(addr) & 0x1FFFFFUL)+SRC_VIRTUAL_BASE)
#define DST_VIRTUAL_PTR(addr) ((void*)DST_VIRTUAL_ADDR(addr))
#define SRC_VIRTUAL_PTR(addr) ((void*)SRC_VIRTUAL_ADDR(addr))

// Set to 0 to test mem64 function
#define DISABLE_AMD64 1

extern void memory_paging_init(void);
extern void memory_paging_enable(void);
extern void memory_paging_disable(void);
extern void memory_paging_map_for_transfer(unsigned long long dst_addr, unsigned long long src_addr);

unsigned char memory_paging_initialized = 0;

void memory_paging_init()
{
// prepare PDP, PDT
unsigned long long *paging_PML4 = (unsigned long long *)PAGING_PML4_ADDR;
unsigned long long *paging_PDPT = (unsigned long long *)PAGING_PDPT_ADDR;
unsigned long long *paging_PD = (unsigned long long *)PAGING_PD_ADDR;
unsigned long long a;

paging_PML4[0] = PAGING_PDPT_ADDR | PML4E_P;
_memset(paging_PML4+1,0,4096-8*1);

paging_PDPT[0] = PAGING_PD_ADDR | PDPTE_P;
_memset(paging_PDPT+1,0,4096-8*1);

// virtual address 0-16MB = physical address 0-16MB
paging_PD[ 0] = a = 0ULL | (PDE_P|PDE_RW|PDE_US|PDE_PS|PDE_G);
paging_PD[ 1] = (a += 0x200000);
paging_PD[ 2] = (a += 0x200000);
paging_PD[ 3] = (a += 0x200000);
paging_PD[ 4] = (a += 0x200000);
paging_PD[ 5] = (a += 0x200000);
paging_PD[ 6] = (a += 0x200000);
paging_PD[ 7] = (a += 0x200000);
_memset(paging_PD+8,0,4096-8*8);

memory_paging_initialized = 1;
}
void memory_paging_map_for_transfer(unsigned long long dst_addr, unsigned long long src_addr)
{
unsigned long long *paging_PD = (unsigned long long *)PAGING_PD_ADDR;
unsigned long long a;
if (!memory_paging_initialized)
      memory_paging_init();
// map 5 2MB-pages for transfer up to 4*2MB.
// virtual address 16MB 0x01000000
paging_PD[ 8] = a = (dst_addr&(-2ULL<<20)) | (PDE_P|PDE_RW|PDE_US|PDE_PS);
paging_PD[ 9] = (a += 0x200000);
paging_PD[10] = (a += 0x200000);
paging_PD[11] = (a += 0x200000);
paging_PD[12] = (a += 0x200000);
// virtual address 32MB 0x02000000
paging_PD[16] = a = (src_addr&(-2ULL<<20)) | (PDE_P|PDE_RW|PDE_US|PDE_PS);
paging_PD[17] = (a += 0x200000);
paging_PD[18] = (a += 0x200000);
paging_PD[19] = (a += 0x200000);
paging_PD[20] = (a += 0x200000);
// invalidate non-global TLB entries
{ int r0;
   asm volatile ("movl %%cr3,%0; movl %0,%%cr3" : "=&q"(r0) : : "memory");
}
}
void memory_paging_enable()
{
if (!memory_paging_initialized)
      memory_paging_init();
// enable paging
{
   int r0,r1;
   asm volatile (
      "movl %%cr0, %0; movl %%cr4, %1; \n\t"
      "orl  $0x80000001,%0; \n\t" // CR0.PE(bit0)|PG(bit31)
      "orl  $0x00000030,%1; \n\t" // CR4.PAE(bit4)|PSE(bit5)
      "movl %1, %%cr4; \n\t"  // set PAE|PSE
      "movl %2, %%cr3; \n\t"  // point to PDPT
      "movl %0, %%cr0; \n\t"  // set PE|PG
      "ljmp %3,$(1f) \n1:\t"  // flush instruction cache
      //"movl %4, %0; movl %0, %%ds; movl %0, %%es; movl %0, %%ss;" // reload DS,ES,SS
      "btsl $7, %1; \n\t"  // CR4.PGE(bit7)
      "movl %1, %%cr4; \n\t"  // set PGE
      :"=&r"(r0),"=&r"(r1)
      :"r"(PAGING_PDPT_ADDR),
      "i"(PROT_MODE_CSEG),
      "i"(PROT_MODE_DSEG)
      :"memory");
}
}
void memory_paging_disable()
{
int r0;
asm volatile (
      "movl %%cr0,%0;  andl %1,%0;  movl %0,%%cr0; \n\t"
      "ljmp %3,$(1f) \n1:\t"  // flush instruction cache
      "movl %%cr4,%0;  andl %2,%0;  movl %0,%%cr4; \n\t"
      "             xorl %0,%0;  movl %0,%%cr3; \n\t"
      :"=&a"(r0)
      :"i"(~(CR0_PG)),
      "i"(~(CR4_PSE|CR4_PAE|CR4_PGE)),
      "i"(PROT_MODE_CSEG)
      :"memory");
}

/*
Transfer data in memory.
Limitation:
code must be below 16MB as mapped by memory_paging_init function
*/
unsigned long long
grub_memmove64(unsigned long long dst_addr, unsigned long long src_addr, unsigned long long len)
{
if (!len)    { errnum = 0; return dst_addr; }
if (!dst_addr) { errnum = ERR_WONT_FIT; return 0; }

// forward copy should be faster than backward copy
// If src_addr < dst_addr < src_addr+len, forward copy is not safe, so we do backward copy in that case.
unsigned char backward = ((src_addr < dst_addr) && (dst_addr < src_addr+len));
unsigned long highaddr = (unsigned long)( dst_addr    >>32)
                        | (unsigned long)((dst_addr+len-1)>>32)
                        | (unsigned long)( src_addr    >>32)
                        | (unsigned long)((src_addr+len-1)>>32);
if ( highaddr==0 )
{ // below 4GB just copy it normally
      void *pdst = (void*)(unsigned long)dst_addr;
      void *psrc = (void*)(unsigned long)src_addr;
      if (backward)
         _memcpy_backward(pdst, psrc, len);
      else
         _memcpy_forward(pdst, psrc, len);
      errnum = 0; return dst_addr;
}
else if ( (highaddr>>(52-32))==0 && (is64bit & IS64BIT_AMD64) && !DISABLE_AMD64)
{ // AMD64/IA32-e paging
      mem64 (1, dst_addr, src_addr, len);       /* 1 for MOVE */
      return dst_addr;
}
else if ( (highaddr>>(52-32))==0 && (is64bit & IS64BIT_PAE))
{ // PAE paging
      void *pdst = DST_VIRTUAL_PTR(dst_addr);
      void *psrc = SRC_VIRTUAL_PTR(src_addr);
      unsigned long long dsta = dst_addr, srca = src_addr;
      memory_paging_enable();
      memory_paging_map_for_transfer(dsta, srca);
      // transfer
      unsigned long long nr = len; // number of bytes remaining
      while (1)
      {
         unsigned long n1 = (nr>=PAGINGTXSTEP)? PAGINGTXSTEP: (unsigned long)nr;  // number of bytes per round (8MB)
         // Copy
         if (backward)
            _memcpy_backward(pdst, psrc, n1);
         else
            _memcpy_forward(pdst, psrc, n1);
         // update loop variables
         if ((nr -= n1)==0) break;
         memory_paging_map_for_transfer((dsta+=n1), (srca+=n1));
      }
      memory_paging_disable();
      errnum = 0; return dst_addr;
}
else
{
      errnum = ERR_WONT_FIT; return 0;
}
}
unsigned long long
grub_memset64(unsigned long long dst_addr, unsigned int data, unsigned long long len)
{
if (!len)    { errnum=0; return dst_addr; }
if (!dst_addr) { errnum = ERR_WONT_FIT; return 0; }
unsigned long highaddr = (unsigned long)( dst_addr    >>32)
                        | (unsigned long)((dst_addr+len-1)>>32);
if ( highaddr==0 )
{ // below 4GB
      _memset((void*)(unsigned long)dst_addr, data, len);
      errnum = 0; return dst_addr;
}
else if ( (highaddr>>(52-32))==0 && (is64bit & IS64BIT_AMD64) && !DISABLE_AMD64)
{ // AMD64/IA32-e paging
      mem64 (3, dst_addr, data, len);       /* 3 for SET */
      return dst_addr;
}
else if ( (highaddr>>(52-32))==0 && (is64bit & IS64BIT_PAE))
{ // PAE paging
      void *pdst = DST_VIRTUAL_PTR(dst_addr);
      unsigned long long dsta = dst_addr;
      memory_paging_enable();
      memory_paging_map_for_transfer(dsta, dsta);
      // transfer
      unsigned long long nr = len; // number of bytes remaining
      while (1)
      {
         unsigned long n1 = (nr>=PAGINGTXSTEP)? PAGINGTXSTEP: (unsigned long)nr;  // number of bytes per round (8MB)
         // Copy
         _memset(pdst, data, n1);
         // update loop variables
         if ((nr -= n1)==0) break;
         dsta+=n1;
         memory_paging_map_for_transfer(dsta, dsta);
      }
      memory_paging_disable();
      errnum = 0; return dst_addr;
}
else
{
      errnum = ERR_WONT_FIT; return 0;
}
}
int
grub_memcmp64(unsigned long long str1addr, unsigned long long str2addr, unsigned long long len)
{
if (!len)    { errnum=0; return 0; }
unsigned long highaddr = (unsigned long)( str1addr    >>32)
                        | (unsigned long)((str1addr+len-1)>>32)
                        | (unsigned long)( str2addr    >>32)
                        | (unsigned long)((str2addr+len-1)>>32);
if ( highaddr==0 )
{ // below 4GB
      return _memcmp((const char*)(unsigned long)str1addr,
         (const char*)(unsigned long)str2addr, (unsigned long)len);
}
else if ( (highaddr>>(52-32))==0 && (is64bit & IS64BIT_AMD64) && !DISABLE_AMD64)
{ // AMD64/IA32-e paging
      return mem64 (2, str1addr, str2addr, len);       /* 2 for CMP */
}
else if ( (highaddr>>(52-32))==0 && (is64bit & IS64BIT_PAE))
{ // PAE paging
      void *p1 = DST_VIRTUAL_PTR(str1addr);
      void *p2 = SRC_VIRTUAL_PTR(str2addr);
      unsigned long long a1=str1addr, a2= str2addr;
      unsigned long long nr = len; // number of bytes remaining
      int r=0;
      memory_paging_enable();
      memory_paging_map_for_transfer(a1, a2);
      {
         while (1)
         {
            unsigned long n1 = (nr>=PAGINGTXSTEP)? PAGINGTXSTEP: (unsigned long)nr;  // number of bytes per round (8MB)
            // Compare
            r = _memcmp(p1, p2, n1);
            if (r) break;
            // update loop variables
            if ((nr -= n1)==0) break;
            memory_paging_map_for_transfer((a1+=n1), (a2+=n1));
         }
      }
      memory_paging_disable();
      return r;
}
else
{
      errnum = ERR_WONT_FIT; return 0;
}
}

		自动登录	找回密码
密码			注册