OSDev.org

Hi there!

I am following James Molloy's Kernel tutorial, which is in turn based on Brandon Friesen's Kernel tutorial. Looking at old posts in this forum, it seems these are popular tutorials.

Unlike James, I opted to use QEMU (with GDB) instead of Bochs. Apart from the makefile (where I redirected the kernel elf to QEMU instead of Bochs) my code is essentially identical to his.

However, I cannot get the GDT part of the code/tutorial to work. Specifically, the gdt_flush assembly:



When I stepi in GDB, I can see that all is going as expected until it reaches the instruction. At which point a triple fault is raised.

I've googled around and some of the answers I have seen mention something about this instruction not being allowed in protected mode. What does that mean? Is it the cause of the fault? If it is, what can I do to address it? I suspect it is due to my use of QEMU (and GDB) rather than Bochs as otherwise the tutorial would have mentioned (and addressed) it.

Edit:
Link to my code

It means the segment register cannot be loaded with a segment selector.
There are multiple specific reasons, but the most likely ones in your case are:

• the selector falls outside the table (selector too large or table too small)
• the descriptor that the selector points to is somehow wrong (e.g. wrong segment type)

So you need to make sure your GDTR and GDT are correct and the selector that you're loading into the segment register makes sense.

If my code is exactly the same as the tutorial's (apart from the makefile), why does it fail for my case but work in the tutorial? I haven't modified any of the values.

It might help if you gave a link to the repository of your code. Otherwise it's just guesswork.

I added a link to my code.

The only thing that strikes me immediately is that you are using a 16-bit pointer for the base address in gdt_entry_struct, when it should be a 32-bit pointer. That's certainly going to cause problems.

If it's not that, you should set a breakpoint just before you load the segment registers. Then you can inspect the GDT in memory to see that it is correct. Also, you can use the qemu monitor to obtain information about the GDT.

Edit: I'm not sure why I said "if it's not that"; your code is loaded above the 64K mark so any pointers must be 32-bit. Using a 16-bit pointer is an absolute show-stopper.

The order of the fields in the gdt entry is incorrect as well. It doesn't match the one in the osdev wiki, and the osdev wiki matches the intel manual, so the source must be wrong.

Facepalm! Thank you!
I guess my code isn't an exact copy (I'll have to comb over it again).

The order matters? 0.0! The tutorial's order follows that in the link you shared. I just changed it for legibility, I didn't think it mattered.

Thank you, both things pointed out were the issue. The code now works!