Etienne Lorrain (etienne_lorrain.delete@this.yahoo.fr) on March 4, 2021 6:58 am wrote:
> You cannot "only initialising a page when it was allocated" because the BIOS do not allocate
> memory, it just tells you how much memory is available, and the concept of page is not known
> (no virtual memory at that point). Moreover the page size is decided by the OS, processor support
> different sizes. Moreover memory over 1 Megabyte was special, either EMS or XMS or HMA.
> And you could not modify DOS, proprietary software with no source.
> The real missing thing was (and still partly is) a proper DMA, able to send more than 64 Kbytes
> and able to access more than 1 Megabyte / 16 Mbytes with chipset recognition and NDA docs.

These all seem like non-issues.

For OSes which cannot handle uninitialized ECC, have a forward-compatibility flag somewhere in the boot loader which means "I can handle uninitialized ECC". If it's not present, BIOS clears memory before transferring to the boot loader. A chaining boot loader (LILO or whatever) is required to do the same check on OSes is chain-loads. (By calling back into the BIOS which has all the necessary code, so the chain loader doesn't suffer much code bloat.)

For loaders which do support uninitialized ECC, a simple BIOS data structure (like the 0xE820 memory map) describes the initialized parts, and there are BIOS calls to extend the initialized parts.

The loader asks the BIOS to initialize enough to hold whatever it's chain-loading, and that loader does the same for its own bss and initial stack.

Then the OS's early boot probes the hardware to find out if it's capable of talking to the ECC hardware without BIOS support. If not, before the BIOS is fully disabled, fall back to asking it to initialize everything.

With all of those fallbacks implemented, the hopefully common case is that the OS does know how to drive the ECC hardware and it initializes its own memory allocator with all unallocated memory flagged "ECC bad". The first time that memory is allocated, it is initialized (which may be as simple as CLZERO).

Since the OS is doing all of this, it understands the page size and all the necessary rules. The important point is that the initialization is done lazily, after applications have started running.

A more sophisticated OS might extend the idea of "potentially uninitialized page" beyond the memory allocator proper, and things like disk DMA which are going to overwrite the whole page could elide the initialization. Since this overlaps heavily with the zeroing required for security, it's not actually a major project.

This all seems like a pretty straightforward SMOP.