CHAPTER 4. ENTERING 32-BIT PROTECTED MODE 35
- Granularity: 1, if set, this multiplies our limit by 4 K (i.e. 161616), so our
0xfffff would become 0xfffff000 (i.e. shift 3 hex digits to the left), allowing
our segment to span 4 Gb of memory - 32-bit default: 1, since our segment will hold 32-bit code, otherwise we’d use
0 for 16-bit code. This actually sets the default data unit size for operations
(e.g. push 0x4 would expand to a 32-bit number ,etc.) - 64-bit code segment: 0, unused on 32-bit processor
- AVL: 0, We can set this for our own uses (e.g. debugging) but we will not
use it
Since we are using a simple flat model, with two overlapping code and data segments,
thedatasegment will be identical but for the type flags:
- Code: 0 for data
- Expand down: 0. This allows the segment to expand down - TODO
explain this - Writable: 1. This allows the data segment to be written to, otherwise
it would be read only - Accessed: 0 This is often used for debugging and virtual memory
techniques, since the CPU sets the bit when it accesses the segment
Now that we have seen an actual configuration of two segments, exploring most of
the possible segment descriptor settings, it should be clearer how protected mode offers
much more flexibilty in the partioning of memory than real mode.
4.3 Defining the GDT in Assembly
Now that we understand what segment descriptors to include in our GDT for the basic
flat model, let us look at how we might actually represent the GDT in assembly, a task
that requires more patience than anything else. Whilst you’re experiencing the shear
tediousness of this, keep in mind the significance of it: what we do here will allow us
soon to boot our operating system kernel, which we will write in a higher level language,
then --- for want of a better quote --- our small steps will turn into giant leaps.
We have already seen examples of how to define data within our assembly code,
using thedb,dw, andddassembly directives, and these are exactly what we must use to
put in place the appropriate bytes in the segment descriptor entries of our GDT.
Actually, for the simple reason that the CPU needs to know how long our GDT is,
we don’t actually directly give the CPU the start address of our GDT but instead give it
the address of a much simpler structure called the GDT descriptor (i.e. something that
describes the GDT). The GDT is a 6-byte structure containing:
- GDT size (16 bits)
- GDT address (32 bits)
Note, when working in such a low-level language with complex data structures like
these, we cannot addenoughcomments. The following code defines our GDT and the
GDT descriptor; in the code, notice how we usedb,dw, etc. to fill out parts of the