My preference is to load the kernel using BIOS functions. In this case, you need to load the kernel from disk before switching to PMode. Bear in mind that either your kernel will have to entirely fit in the space before the BIOS area at around 0x90000 or you will have to use unreal mode/PMode to copy the kernel to above 1MiB as you load it. You can then switch to Pmode and jump to your kernel.Do i need to set up pmode before i load the kernel from the disk?
As long as you can directly manipulate bits at known memory locations in Pascal, yes. I believe there is a Pascal barebones on the wiki and/or other people here have written Pascal kernels, so the answer must be yes.The other question is can i use pascal functions to set up my gdt and idt?
Assuming a flat binary loaded at the 1MiB mark:The last one is how do i jump from my boot loader into my kernel
Code: Select all
JMP 0x100000
You can load your kernel either byDo i need to set up pmode before i load the kernel from the disk?
Theoretically yes, but use ASM routines for that, you'll get a faster code plus you'll avoid some number of strange bugs. Really. - This applies only when your kernel is loaded by pmode bootloader!!! (When in real mode you need to set up pmode in asm.)The other question is can i use pascal functions to set up my gdt and idt?
When you have the protected mode fully set up, this can be doneThe last one is how do i jump from my boot loader into my kernel
.Oh really? First, when setting up a GDT it is absolutely useless to go for 'speed' as it is a one-time thing that'll take a nano-second on a modern CPU, regardless of whether you code in asm or a high-level language, and secondly, what 'strange bugs' are you thinking about? As long as you know your compiler and are able to align everything properly, there shouldn't be any 'strange bugs' (or any bug, for that matter). I've set up my GDT in C++, and it works perfectly well.inflater wrote:Theoretically yes, but use ASM routines for that, you'll get a faster code plus you'll avoid some number of strange bugs. Really.
Theoretically this can be accomplished, but wait until you get the first triple fault by e.g. mis-aligned tables. Therefore it's easier, faster and safer to do it in ASM.Code: Select all
unit gdt;
interface
type
TGDTEntry = packed record
LowLimit: Word;
LowBase: Word;
MiddleBase: Byte;
Access: Byte;
Granularity: Byte;
HighBase: Byte;
end;
TGDTPtr = packed record
Limit: Word;
Base: LongWord;
end;
var
GDTList: array [0..4] of TGDTEntry;
GDTPtr: TGDTPtr;
procedure SetGDTGate(num: LongInt; base,limit: LongWord; acc,gran: Byte);
procedure InstallGDT;
implementation
uses
console; // Write* routines are defined here
procedure FlushGDT; assembler; nostackframe;
label
flush;
asm
lgdt [GDTPtr]
mov ax,$10
mov ds,ax
mov es,ax
mov fs,ax
mov gs,ax
mov ss,ax
// jmp $08:flush // don't know the correct syntax in FPC inline assembler, but it works!
flush:
end;
procedure SetGDTGate(num: LongInt; base,limit: LongWord; acc,gran: Byte);
begin
with GDTList[num] do begin
LowBase:=(base and $FFFF);
MiddleBase:=(base shr 16) and $FF;
HighBase:=(base shr 24) and $FF;
LowLimit:=(limit and $FFFF);
Granularity:=((limit shr 16) and $0F);
Granularity:=Granularity or (gran and $F0);
Access:=acc;
end;
end;
procedure InstallGDT;
begin
WriteString('Installing GDT... ');
with GDTPtr do begin
Limit:=SizeOf(GDTList)-1;
Base:=PtrUInt(@GDTList);
end;
SetGDTGate(0,0,0,0,0); // nil descriptor
SetGDTGate(1,0,$FFFFFFFF,$9A,$CF); // Kernel space code
SetGDTGate(2,0,$FFFFFFFF,$92,$CF); // Kernel space data
SetGDTGate(3,0,$FFFFFFFF,$FA,$CF); // User space code
SetGDTGate(4,0,$FFFFFFFF,$F2,$CF); // User space data
FlushGDT;
WriteStrLn('Done.');
end;
end.
You should also check allignment of the actual declared variables.System123 wrote:My GDT setup function looks very similar to the one above. The only thing is I forgot to use packed records.