User:Johnburger/Demo/Exec/Alloc/LDT

This module provides four functions, to allocate LDTs and then to allocate Entries inside them.

Allocating the memory for a new LDT is easy, but the code assumes that the LDT will need some tailoring done to it before it will become a true LDT. For that reason Exec.Alloc.LDT returns a Data Segment, and expects Exec.Alloc.LDT.Enable to be CALLed when finished so that it can convert it to a true LDT.

The last two functions use those found in Demo/Exec/Alloc/DT, which convert the passed-in parameters as necessary to make them fit inside the new Entry.

Exec.Alloc.LDT

This function allocates a new Data Segment with the passed-in size, and sets up the first couple of Entries in the nascent LDT for future Allocate purposes.

Exec.Alloc.LDT.Enable

This function converts the Data Segment into a true LDT.

Exec.Alloc.LDT.Sys

This Allocates a new System Descriptor in the LDT.

Exec.Alloc.LDT.Mem

This Allocates a new Memory Descriptor in the LDT.

Demo/Exec/Alloc/LDT.inc

;
; Exec/Alloc/LDT.inc
;

; This module provides functions to create LDTs and allocate entries in them.

;-------------------------------------------------------------------------------
; This function:
; 1) Allocates the requested RAM for an LDT;
; 2) Fills in the first entry with LDT.Alloc;
; 3) Fills in the second entry with an alias for this LDT (useful for debugging)
; 4) Returns a Data Descriptor for the LDT, ready for more customisation.
; To actually turn it into an LDT, call Exec.Alloc.LDT.Enable.
;
; Input:  ECX = Size
; Output: AX  = GDT Descriptor for (future) LDT, or zero on error
;         ES  = GDT Descriptor unless AX is zero
Exec.Alloc.LDT:

%push Alloc.LDT ; Let's not leave these %defines just lying around...
%define         %$Base          EBP - 4
%define         %$Size          EBP - 8

                ENTER           8, 0

                MOV             [%$Size], ECX

                CALL            Exec.Alloc.RAM
                TEST            EAX,EAX          ; Any left?
                JZ              .End             ; Pity that!

                MOV             [%$Base],EAX

                MOV             EBX,EAX          ; Base to allocate
                MOV             DL,Type.Mem(Data, DPL0, RW)
                MOV             DH,Gran.Mem(Byte, Small)
                CALL            Exec.Alloc.GDT.Mem ; Get Descriptor to use
                TEST            EAX,EAX          ; Any left?
                JZ              .End             ; Pity that! **** Memory leak! ****

                MOV             ES,AX            ; Fresh Descriptor!
                MOV             ECX,[%$Size]     ; Bytes to zero
                XOR             EDI,EDI          ; Zero everything
                CALL            Exec.Alloc.RAM.Zero

                ; Set up first entry as an LDT.Alloc
                MOV     WORD    [ES:LDT.Alloc.Limit],x86.Desc_size - 1
                MOV     BYTE    [ES:LDT.Alloc.Type],x86.Desc.Sys.Type.LDT
                MOV             [ES:LDT.Alloc.GDT],ES

                ; Set up second entry as an alias for this very LDT
                MOV             EAX,[%$Base]            ; Pass Base in
                MOV             ECX,[%$Size]            ; Size
                MOV             DL,Type.Mem(Data, DPL0, RW)
                MOV             DH,Gran.Mem(Byte, Small)
                CALL            Exec.Alloc.LDT.Mem      ; Allocate LDT entry

                MOV             AX,ES                   ; Return value
.End:
                LEAVE
%pop
                RET
;-------------------------------------------------------------------------------
; This function converts a Segment previously allocated with Alloc.LDT (above)
; into a true LDT.
;
; Input:  ES = Descriptor to modify
; Output: ES, EBX modified
Exec.Alloc.LDT.Enable:

; Note that I could use GS: overrides to access the GDT, but ES points to the
; soon-to-be LDT - a Bad Thing. This fixes that!
                MOV             EBX, ES         ; Get Descriptor to modify

                MOV             AX,GS           ; Get GDT into ES
                MOV             ES,AX

                MOV     BYTE    [ES:EBX+x86.Desc.Type],Type.Sys(LDT, DPL0, 286)

                RET
;-------------------------------------------------------------------------------
; This function allocates a new Desc.Sys in an LDT
; Input:  ES     = LDT to modify
;         CX:EAX = Selector : Offset of handler
;         DL     = Descriptor Type
; Output: EAX    = Allocated Descriptor, or zero on error
;         EBX, ESI, EDI modified

Exec.Alloc.LDT.Sys:
                PUSH            EAX             ; Save for later
                CALL            Exec.Alloc.DT   ; Allocate an Entry
                MOV             EBX,EAX         ; This is Descriptor to modify

                TEST            EAX,EAX         ; Any left?
                POP             EAX             ; It's later!
                JZ              .Finish         ; Uh oh!

                CALL            Exec.Alloc.DT.Sys ; Call helper function

.Finish:
                MOV             EAX,EBX         ; Return value
                RET

;-------------------------------------------------------------------------------
; This function allocates a new Desc.Mem in an LDT
; Input:  ES     = LDT to modify
;         EAX    = Base
;         ECX    = Size (Converted to Limit)
;         DL     = Descriptor Type
;         DH     = Descriptor Granularity
; Output: EAX    = Allocated Descriptor, or zero on error
;         EBX, ECX, DH, ESI, EDI modified

Exec.Alloc.LDT.Mem:
                PUSH            EAX             ; Save for later
                CALL            Exec.Alloc.DT   ; Allocate an Entry
                MOV             EBX,EAX         ; This is Descriptor to modify

                TEST            EAX,EAX         ; Any left?
                POP             EAX             ; It's later!
                JZ              .Finish         ; Uh oh!

                CALL            Exec.Alloc.DT.Mem ; Call helper function

.Finish:
                MOV             EAX,EBX         ; Return value
                RET