http://wiki.amc-os.com/api.php?action=feedcontributions&feedformat=atom&user=KindmanAMC-OS Developers - User contributions [en]2026-06-02T14:37:54ZUser contributionsMediaWiki 1.39.12http://wiki.amc-os.com/index.php?title=Memory_initialization&diff=112Memory initialization2022-09-10T23:13:52Z<p>Kindman: /* First megabyte */</p>
<hr />
<div>=During AMC-OS Loader=<br />
<br />
To get size and map of memory, AMC-OS Loader now relies mainly on BIOS instead of probing, which was the preferred way in AMC-OS <2.10.<br />
<br />
AMC-OS Loader proceed this way :<br />
* Try INT 15H, function E820 to get memory map.<br />
* Try INT 15H, function E801 to get size of memory below 16MB and above 16MB<br />
* Try INT 15H, function 88 to get effective size of extended memory<br />
* Get configured size of extended memory in CMOS<br />
<br />
Depending on functions supported by BIOS, map will be more or less precise, and memory might be lost if ISA Hole in the 15-16M area is configured. <br />
<br />
After AMC-OS Loader execution, the first megabyte of memory is divided like this :<br />
{| class="wikitable"<br />
|<code>00000-003FF</code><br />
|Real-mode interrupt table (for V86)<br />
|-<br />
|<code>00400-00500</code><br />
|BIOS static data (for V86)<br />
|-<br />
|<code>00501-007FF</code><br />
|Partially allocated memory by <code>AMCOSLDR_DefinitiveAlloc</code><br />
|-<br />
|<code>00800-[__A]</code><br />
|Kernel static data<br />
|-<br />
|<code>[__A]-077FF</code><br />
|Partially allocated memory by <code>AMCOSLDR_DefinitiveAlloc</code><br />
|-<br />
|<code>077FF-07BFF</code><br />
|AMC-OS Loader stack (''no longer used- reclaimable'')<br />
|-<br />
|<code>07C00-07DFF</code><br />
|Boot loader code (''no longer used - reclaimable'')<br />
|-<br />
|<code>07E00-07FFF</code><br />
|Free (''unused - reclaimable'')<br />
|-<br />
|<code>08000-9[_D]</code><br />
|Partially allocated memory by <code>AMCOSLDR_DefinitiveAlloc</code>, including Kernel<br />
|-<br />
|<code>9[_D]-9FFFF</code><br />
|Extended BIOS data area (EBDA - optional)<br />
|}<br />
All reclaimable memory is added to the SMALLOC structures of AMC-OS Loader, than will be analyzed by Kernel.<br />
<br />
End of 1st megabyte, segment-like, [_D] or A000H is stored in <code>MEMORY_BaseMaxSegment</code>.<br />
<br />
=Kernel start=<br />
<br />
Process of memory initialization by Kernel is the following :<br />
<br />
* Initialization of 1st MB of memory : AMC-OS uses information discovered by the loader to build initial memory structures.<br />
* A20 gate unlocking to access memory above 1MB<br />
* Initialization of all physical memory<br />
<br />
==Initialization of first megabyte==<br />
Kernel starts by calling <code>INIT_MemoryUsableIn1stMeg()</code>. The function determines the first address of free memory in the first megabyte, just after kernel relocation code and below EBDA. It checks that it matches with AMC-OS Loader MALLOC structure, as its last allocatable block should start just after kernel relocation code. <br />
<br />
The function fills :<br />
* <code>MEMORY_FreePageAddrIn1stMeg</code><br />
* <code>MEMORY_FreePagesIn1stMeg</code><br />
which allow the call to <code>INIT_AllocatePagesBelow()</code> for allocation of contiguous pages of memory during initialization.<br />
<br />
It also calls <code>INIT_MemorySmallocInit</code>, which rebuilds AMC-OS Loader SMALLOC structures with 32-byte direct offsets to have a quick function for small memory allocation during memory initialization : <code>INIT_MemoryDefinitiveAlloc()</code> .<br />
<br />
At this point, all unused memory by AMC-OS Loader is reclaimed by kernel, and 1st megabyte of memory is fully analyzed.<br />
<br />
==A20 Gate==<br />
Kernel unlocks A20 gate by calling <code>INIT_A20Gate</code>.<br />
<br />
A20 gate was controlled by keyboard controller on AT+. To allow compatibility with 8086/8088, the A20 address line was forced to 0 on AT computers, blocking access to memory above 1MB. A20 gate must be enabled to allow A20 address line to be used normally.<br />
<br />
==Physical memory initialization==<br />
Physical memory is initialized by calling <code>INIT_GlobalMemory</code>.<br />
<br />
===Memory map===<br />
The function first builds a map of physical memory :<br />
* If available, it relies first on type-1 (available) entries of E820 BIOS records. ''In current release, memory above 4GB is ignored''.<br />
* If available, it relies on E801 BIOS call results to determine a block of memory below 16MB and a block of memory above 16MB.<br />
* In other cases, kernel do a manual probing of available memory, using function <code>INIT_MemoryCheckSegment</code>.</div>Kindmanhttp://wiki.amc-os.com/index.php?title=Memory_initialization&diff=111Memory initialization2022-09-10T22:59:26Z<p>Kindman: /* During AMC-OS Loader */</p>
<hr />
<div>=During AMC-OS Loader=<br />
<br />
To get size and map of memory, AMC-OS Loader now relies mainly on BIOS instead of probing, which was the preferred way in AMC-OS <2.10.<br />
<br />
AMC-OS Loader proceed this way :<br />
* Try INT 15H, function E820 to get memory map.<br />
* Try INT 15H, function E801 to get size of memory below 16MB and above 16MB<br />
* Try INT 15H, function 88 to get effective size of extended memory<br />
* Get configured size of extended memory in CMOS<br />
<br />
Depending on functions supported by BIOS, map will be more or less precise, and memory might be lost if ISA Hole in the 15-16M area is configured. <br />
<br />
After AMC-OS Loader execution, the first megabyte of memory is divided like this :<br />
{| class="wikitable"<br />
|<code>00000-003FF</code><br />
|Real-mode interrupt table (for V86)<br />
|-<br />
|<code>00400-00500</code><br />
|BIOS static data (for V86)<br />
|-<br />
|<code>00501-007FF</code><br />
|Partially allocated memory by <code>AMCOSLDR_DefinitiveAlloc</code><br />
|-<br />
|<code>00800-[__A]</code><br />
|Kernel static data<br />
|-<br />
|<code>[__A]-077FF</code><br />
|Partially allocated memory by <code>AMCOSLDR_DefinitiveAlloc</code><br />
|-<br />
|<code>077FF-07BFF</code><br />
|AMC-OS Loader stack (''no longer used- reclaimable'')<br />
|-<br />
|<code>07C00-07DFF</code><br />
|Boot loader code (''no longer used - reclaimable'')<br />
|-<br />
|<code>07E00-07FFF</code><br />
|Free (''unused - reclaimable'')<br />
|-<br />
|<code>08000-9[_D]</code><br />
|Partially allocated memory by <code>AMCOSLDR_DefinitiveAlloc</code>, including Kernel<br />
|-<br />
|<code>9[_D]-9FFFF</code><br />
|Extended BIOS data area (EBDA - optional)<br />
|}<br />
All reclaimable memory is added to the SMALLOC structures of AMC-OS Loader, than will be analyzed by Kernel.<br />
<br />
=Kernel start=<br />
<br />
When Kernel starts, AMC-OS uses information discovered by the loader to build memory structures.<br />
<br />
==First megabyte==<br />
Kernel starts by calling <code>INIT_MemoryUsableIn1stMeg</code>. The function determines the first address of free memory in the first megabyte, just after kernel relocation code and below EBDA.<br />
<br />
The function fills :<br />
* <code>MEMORY_FreePageAddrIn1stMeg</code><br />
* <code>MEMORY_FreePagesIn1stMeg</code><br />
<br />
==A20 Gate==<br />
Kernel unlocks A20 gate by calling <code>INIT_A20Gate</code>.<br />
<br />
A20 gate was controlled by keyboard controller on AT+. To allow compatibility with 8086/8088, the A20 address line was forced to 0 on AT computers, blocking access to memory above 1MB. A20 gate must be enabled to allow A20 address line to be used normally.<br />
<br />
==Physical memory initialization==<br />
Physical memory is initialized by calling <code>INIT_GlobalMemory</code>.<br />
<br />
===Memory map===<br />
The function first builds a map of physical memory :<br />
* If available, it relies first on type-1 (available) entries of E820 BIOS records. ''In current release, memory above 4GB is ignored''.<br />
* If available, it relies on E801 BIOS call results to determine a block of memory below 16MB and a block of memory above 16MB.<br />
* In other cases, kernel do a manual probing of available memory, using function <code>INIT_MemoryCheckSegment</code>.</div>Kindmanhttp://wiki.amc-os.com/index.php?title=Memory_initialization&diff=110Memory initialization2022-09-10T22:57:57Z<p>Kindman: Added memory map after execution of AMC-OS Loader</p>
<hr />
<div>=During AMC-OS Loader=<br />
<br />
To get size and map of memory, AMC-OS Loader now relies mainly on BIOS instead of probing, which was the preferred way in AMC-OS <2.10.<br />
<br />
AMC-OS Loader proceed this way :<br />
* Try INT 15H, function E820 to get memory map.<br />
* Try INT 15H, function E801 to get size of memory below 16MB and above 16MB<br />
* Try INT 15H, function 88 to get effective size of extended memory<br />
* Get configured size of extended memory in CMOS<br />
<br />
Depending on functions supported by BIOS, map will be more or less precise, and memory might be lost if ISA Hole in the 15-16M area is configured. <br />
<br />
After AMC-OS Loader execution, the first megabyte of memory is divided like this :<br />
{| class="wikitable"<br />
|<code>00000-003FF</code><br />
|Real-mode interrupt table (for V86)<br />
|-<br />
|<code>00400-00500</code><br />
|BIOS static data (for V86)<br />
|-<br />
|<code>00501-005FF</code><br />
|Partially allocated memory by <code>AMCOSLDR_DefinitiveAlloc</code><br />
|-<br />
|<code>00600-007FF</code><br />
|''Master boot record (no longer used - reclaimable)''<br />
|-<br />
|<code>00800-[__A]</code><br />
|Kernel static data<br />
|-<br />
|<code>[__A]-[__B]</code><br />
|AMC-OS Loader code (''no longer used - reclaimable'')<br />
|-<br />
|<code>[__B]-[__C]</code><br />
|AMC-OS Loader picture (''no longer used - reclaimable'')<br />
|-<br />
|<code>[__C]-077FF</code><br />
|Partially allocated memory by <code>AMCOSLDR_DefinitiveAlloc</code><br />
|-<br />
|<code>077FF-07BFF</code><br />
|AMC-OS Loader stack (''no longer used- reclaimable'')<br />
|-<br />
|<code>07C00-07DFF</code><br />
|Boot loader code (''no longer used - reclaimable'')<br />
|-<br />
|<code>07E00-07FFF</code><br />
|Free (''unused - reclaimable'')<br />
|-<br />
|<code>08000-9[_D]</code><br />
|Partially allocated memory by <code>AMCOSLDR_DefinitiveAlloc</code>, including Kernel<br />
|-<br />
|<code>9[_D]-9FFFF</code><br />
|Extended BIOS data area (EBDA - optional)<br />
|}<br />
All reclaimable memory is added to the SMALLOC structures of AMC-OS Loader, than will be analyzed by Kernel.<br />
<br />
=Kernel start=<br />
<br />
When Kernel starts, AMC-OS uses information discovered by the loader to build memory structures.<br />
<br />
==First megabyte==<br />
Kernel starts by calling <code>INIT_MemoryUsableIn1stMeg</code>. The function determines the first address of free memory in the first megabyte, just after kernel relocation code and below EBDA.<br />
<br />
The function fills :<br />
* <code>MEMORY_FreePageAddrIn1stMeg</code><br />
* <code>MEMORY_FreePagesIn1stMeg</code><br />
<br />
==A20 Gate==<br />
Kernel unlocks A20 gate by calling <code>INIT_A20Gate</code>.<br />
<br />
A20 gate was controlled by keyboard controller on AT+. To allow compatibility with 8086/8088, the A20 address line was forced to 0 on AT computers, blocking access to memory above 1MB. A20 gate must be enabled to allow A20 address line to be used normally.<br />
<br />
==Physical memory initialization==<br />
Physical memory is initialized by calling <code>INIT_GlobalMemory</code>.<br />
<br />
===Memory map===<br />
The function first builds a map of physical memory :<br />
* If available, it relies first on type-1 (available) entries of E820 BIOS records. ''In current release, memory above 4GB is ignored''.<br />
* If available, it relies on E801 BIOS call results to determine a block of memory below 16MB and a block of memory above 16MB.<br />
* In other cases, kernel do a manual probing of available memory, using function <code>INIT_MemoryCheckSegment</code>.</div>Kindmanhttp://wiki.amc-os.com/index.php?title=AMC-OS_Loader_Memory_management&diff=109AMC-OS Loader Memory management2022-09-03T11:26:57Z<p>Kindman: /* Initialization */</p>
<hr />
<div>=Memory used during AMC-OS Loader execution=<br />
AMC-OS Loader uses only the first megabyte of memory :<br />
{|-<br />
|<code>00000-003FF</code><br />
|Real-mode interrupt table<br />
|-<br />
|<code>00400-00500</code><br />
|BIOS static data<br />
|-<br />
|<code>00501-005FF</code><br />
|Free (unused)<br />
|-<br />
|<code>00600-007FF</code><br />
|''Master boot record''<br />
|-<br />
|<code>00800-[__A]</code><br />
|Kernel static data (initialized by boot loader)<br />
|-<br />
|<code>[__A]-[__B]</code><br />
|AMC-OS Loader code<br />
|-<br />
|<code>[__B]-[__C]</code><br />
|AMC-OS Loader picture<br />
|-<br />
|<code>[__C]-077FF</code><br />
|''Free for allocation''<br />
|-<br />
|<code>077FF-07BFF</code><br />
|AMC-OS Loader stack<br />
|-<br />
|<code>07C00-07DFF</code><br />
|Boot loader code (VBR or MBR for floppy disk)<br />
|-<br />
|<code>07E00-07FFF</code><br />
|Free (unused)<br />
|-<br />
|<code>08000-9[_D]</code><br />
|''Free for allocation''<br />
|-<br />
|<code>9[_D]-09FFF</code><br />
|Extended BIOS data area (EBDA - optional)<br />
|}<br />
<br />
=Memory management=<br />
==Initialization==<br />
During memory initialization process (<code>AMCOSLDR_InitFirstMegabyte</code>), AMC-OS Loader :<br />
* looks for EBDA using interrupt 12H and value stored in 0040:000E to get highest pointer in memory [_D]<br />
* calculates the values of [__C] to get lowest pointer in memory<br />
* creates a linked list of available blocks of memory (<code>AMCOSLDR_Malloc_Entry</code>)<br />
* initializes two blocks of available memory (marked ''Free for allocation'' in previous table)<br />
<br />
==Allocation of 512 bytes or more==<br />
Three main functions are available to AMC-OS Loader for memory allocation. They wait for the requested size in segment size (16-bytes unit), and returns a segment of memory aligned on 512 bytes boundaries to facilitate disk operations. <br />
* <code>AMCOSLDR_DefinitiveAlloc</code> : Used to allocate memory that shall stay at this place at the end of the process (used by kernel afterwards). Memory will be taken from bottom of free memory.<br />
* <code>AMCOSLDR_TempAlloc</code> : Used to allocate memory that will be freed at the end of AMC-OS Loader. Memory will be taken from top of free memory.<br />
* <code>AMCOSLDR_VolatileAlloc</code> : Used to allocate memory for immediate use (valid only until a new call to any memory function is made). Memory will be taken from top of free memory. It typically do the same as <code>AMCOSLDR_TempAlloc</code> but do not consider the memory to be really used, so only the two other functions maintain the linked list of available blocks of memory.<br />
Temporary allocations are reclaimed by kernel later during <code>INIT_MemoryUsableIn1stMeg</code>.<br />
<br />
== Allocation of less than 512 bytes, "Small allocation" ==<br />
For definitive allocation of less than 512 bytes, an other function is available. It also waits for the requested size in segment size (16-bytes unit), and returns a 16-byte aligned memory segment.<br />
<br />
* <code>AMCOSLDR_DefinitiveSmallAlloc</code> : Used to allocate memory that shall stay at this place at the end of the process (used by kernel afterwards). Memory will be taken from bottom of free memory. Small allocation is maintained with a linked list of structures { free_size_in_segment ; ptr_next_segment } stored directly in free memory, and starting by pointer stored in <code>AMCOSLDR_SmallAllocSegPtr</code>. <br />
<br />
After AMC-OS Loader has finished, kernel reclaims the available memory later during <code>INIT_MemorySmallocInit</code>.</div>Kindmanhttp://wiki.amc-os.com/index.php?title=AMC-OS_Loader_Memory_management&diff=108AMC-OS Loader Memory management2022-09-03T11:25:41Z<p>Kindman: </p>
<hr />
<div>=Memory used during AMC-OS Loader execution=<br />
AMC-OS Loader uses only the first megabyte of memory :<br />
{|-<br />
|<code>00000-003FF</code><br />
|Real-mode interrupt table<br />
|-<br />
|<code>00400-00500</code><br />
|BIOS static data<br />
|-<br />
|<code>00501-005FF</code><br />
|Free (unused)<br />
|-<br />
|<code>00600-007FF</code><br />
|''Master boot record''<br />
|-<br />
|<code>00800-[__A]</code><br />
|Kernel static data (initialized by boot loader)<br />
|-<br />
|<code>[__A]-[__B]</code><br />
|AMC-OS Loader code<br />
|-<br />
|<code>[__B]-[__C]</code><br />
|AMC-OS Loader picture<br />
|-<br />
|<code>[__C]-077FF</code><br />
|''Free for allocation''<br />
|-<br />
|<code>077FF-07BFF</code><br />
|AMC-OS Loader stack<br />
|-<br />
|<code>07C00-07DFF</code><br />
|Boot loader code (VBR or MBR for floppy disk)<br />
|-<br />
|<code>07E00-07FFF</code><br />
|Free (unused)<br />
|-<br />
|<code>08000-9[_D]</code><br />
|''Free for allocation''<br />
|-<br />
|<code>9[_D]-09FFF</code><br />
|Extended BIOS data area (EBDA - optional)<br />
|}<br />
<br />
=Memory management=<br />
==Initialization==<br />
During memory initialization process (<code>AMCOSLDR_InitFirstMegabyte</code>), AMC-OS Loader :<br />
* looks for EBDA using interrupt 12H and value stored in 0040:000E to get highest pointer in memory [_D]<br />
* calculates the values of [__A] to get lowest pointer in memory<br />
* creates a linked list of available blocks of memory (<code>AMCOSLDR_Malloc_Entry</code>)<br />
* initializes two blocks of available memory (marked ''Free for allocation'' in previous table)<br />
<br />
==Allocation of 512 bytes or more==<br />
Three main functions are available to AMC-OS Loader for memory allocation. They wait for the requested size in segment size (16-bytes unit), and returns a segment of memory aligned on 512 bytes boundaries to facilitate disk operations. <br />
* <code>AMCOSLDR_DefinitiveAlloc</code> : Used to allocate memory that shall stay at this place at the end of the process (used by kernel afterwards). Memory will be taken from bottom of free memory.<br />
* <code>AMCOSLDR_TempAlloc</code> : Used to allocate memory that will be freed at the end of AMC-OS Loader. Memory will be taken from top of free memory.<br />
* <code>AMCOSLDR_VolatileAlloc</code> : Used to allocate memory for immediate use (valid only until a new call to any memory function is made). Memory will be taken from top of free memory. It typically do the same as <code>AMCOSLDR_TempAlloc</code> but do not consider the memory to be really used, so only the two other functions maintain the linked list of available blocks of memory.<br />
Temporary allocations are reclaimed by kernel later during <code>INIT_MemoryUsableIn1stMeg</code>.<br />
<br />
== Allocation of less than 512 bytes, "Small allocation" ==<br />
For definitive allocation of less than 512 bytes, an other function is available. It also waits for the requested size in segment size (16-bytes unit), and returns a 16-byte aligned memory segment.<br />
<br />
* <code>AMCOSLDR_DefinitiveSmallAlloc</code> : Used to allocate memory that shall stay at this place at the end of the process (used by kernel afterwards). Memory will be taken from bottom of free memory. Small allocation is maintained with a linked list of structures { free_size_in_segment ; ptr_next_segment } stored directly in free memory, and starting by pointer stored in <code>AMCOSLDR_SmallAllocSegPtr</code>. <br />
<br />
After AMC-OS Loader has finished, kernel reclaims the available memory later during <code>INIT_MemorySmallocInit</code>.</div>Kindmanhttp://wiki.amc-os.com/index.php?title=Memory_and_paging&diff=107Memory and paging2022-09-03T09:52:50Z<p>Kindman: </p>
<hr />
<div>= Physical memory management =<br />
For more information on physical memory initialization, refer to ''[[Memory initialization]]'' article.<br />
<br />
== Memory areas ==<br />
<br />
After scanning the linear address space for available physical memory, AMC-OS split the physical memory in two areas :<br />
* The '''low memory area''' must be at least 4Mbytes large, and its size is proportional to the total amount of physical memory available. This area is also referred as ''kernel memory'' as the physical memory is available from all page directories at kernel privilege.<br />
* The '''high memory area''' contains all the remaining memory and is used for user memory.<br />
<br />
Each memory area is divided in blocks of 256Kbytes, and is specified in a <tt>MEMORY_AREA</tt> structure containing :<br />
* the number and pointers to the used blocks they contain;<br />
* the number and pointers to the free blocks they contain;<br />
* the number and pointers to the free pages.<br />
<br />
User memory can be taken from low memory if high memory is exhausted.<br />
<br />
== Blocks management ==<br />
=== Free blocks list ===<br />
<br />
By default, each memory area is divided in blocks of 256 Kbytes. A new block is ''activated'' and divided in free pages, if there are no more free pages available in the area. Free blocks are stored in the ''free blocks list'', a linked list of the '''InactiveMemory''' structure. It contains :<br />
* the pointer to the free block;<br />
* the number of contiguous free blocks;<br />
* the pointer to the next structure.<br />
During initialization phase, we pre-allocate the maximum of free blocks structures that can be necessary, ie half the number of blocks. This list of free blocks structures is also a linked list to accelerate allocating and freeing processes.<br />
<br />
The pointer to the free blocks list is stored in <tt>MEMORY_AREA.ptrFreeBlocks</tt>, and count in <tt>MEMORY_AREA.nbFreeBlocks</tt>.<br />
<br />
The pointer to the free blocks structures list is stored in <tt>MEMORY_ptrInactiveFreeBlocksStruct</tt>, and count in <tt>MEMORY_nbInactiveFreeBlocksStruct</tt>.<br />
<br />
=== Number of free pages per block ===<br />
<br />
A free pages per block table is created to be able to put back in free blocks list a block that has all its pages free.<br />
It is a simple table indexed by the block number, containing for each entry an unsigned byte with the number of free pages. Obviously, there can't be more than 256 pages per block (64 by default).<br />
<br />
== Kernel memory allocation procedures ==</div>Kindmanhttp://wiki.amc-os.com/index.php?title=Threads&diff=103Threads2020-07-29T15:57:00Z<p>Kindman: </p>
<hr />
<div>== Thread definition in AMC-OS ==<br />
<br />
A thread is an execution unit running in the context of a specific [[Processes|process]]. It is consequently limited to the address space, code, data and execution rights of its [[Processes|parent process]]. If we refer to x86 architecture, a thread is the same as a task.<br />
<br />
A thread is characterized by :<br />
* an internal thread ID (ITID) and global thread id (GTID)<br />
* a task state segment (TSS) containing CPU state (registers, stack, ...)<br />
* scheduling data (priority flag, counter of total and remaining active time...)<br />
* a list of events related to the thread<br />
<br />
Threads are managed by the TSI module ''(Threads System Interface)''.<br />
<br />
== Threads System Interface (TSI) ==<br />
<br />
Each process is defined by a <code>TSI_ENTRY</code> containing all thread information.<br />
<br />
=== Thread ID (iTID and TID) ===<br />
<br />
An internal thread ID (iTID) is a 16-bit unsigned integer, uniquely assigned to each thread in the whole system, with a maximum of <code>TSI_MAX_THREADS</code>. The global thread ID (TID) is a 32-bit unsigned integer composed of the PID in the 16 upper bits, and of the ITID in the 16 lower bits.<br />
<br />
TSI maintains a linked list of unsorted used and free iTIDs, allowing allocation and release of iTIDs in ''O(1)'', by respectively removing or adding the iTID at the beginning of the list.<br />
Both list share the same global table called <code>StatusTable</code> with two initial pointers, one for the linked list of free entries (<code>firstFreeEntry</code>), one for the linked list of used entries (<code>firstUsedEntry</code>).<br />
<br />
Internal functions for iTID management are : <br />
* iTID TSI_AllocateTID(TSI_ENTRY *)<br />
* void TSI_ReleaseTID(iTID)<br />
<br />
To get the TSI_ENTRY for a specific iTID, an index table called <code>TSI_QuickTable</code> is maintained.<br />
<br />
== Task scheduling and management ==<br />
<br />
=== Thread status ===<br />
<br />
A thread can mainly be considered as :<br />
* inactive (stopped, waiting for external event, dying)<br />
* active (waiting for execution)<br />
* running (currently executed on a CPU)<br />
<br />
The status of the thread can change in these situations :<br />
* suspension by timer (end of allowed execution time), from running to active. Handled by interrupt task <code>KERNEL_PeriodicTimer</code>.<br />
* suspension request (waiting for an external event, dying), or exception from running to inactive. Handled (finally) by task manager <code>TASKMGR_SwitchTask</code><br />
* activation request (external event occured, new thread), from inactive to active. Handled by <code>TSI</code>.<br />
<br />
=== Active threads list ===<br />
<br />
Active threads are maintained in a circulary doubly linked list. A pointer refers to the next eligible thread for execution.<br />
The list and pointers are modified by the task manager when removing a thread from the list (suspension request), or by TSI when adding a thread to the list (activation request). <br />
<br />
=== Running threads ===<br />
<br />
The currently running thread is directly stored in a table indexed by CPU.<br />
<br />
=== Allowed execution time and priority ===<br />
<br />
The priority defines the amount of allowed contiguous execution time on a CPU. At each timer interrupt, the counter is decremented and when it reaches 0 a new thread is dispatched for execution (except if there is no other thread waiting for execution).<br />
<br />
=== Periodic Timer interrupt ===<br />
<br />
The periodic timer interrupt task :<br />
* decrements threads waiting for timeout<br />
* decrements running threads remaining execution time<br />
* for each CPU that reaches end of execution time, send an IPI to request task change and dispatching of a new thread.</div>Kindmanhttp://wiki.amc-os.com/index.php?title=Threads&diff=102Threads2020-07-29T15:28:28Z<p>Kindman: </p>
<hr />
<div>== Thread definition in AMC-OS ==<br />
<br />
A thread is an execution unit running in the context of a specific [[Processes|process]]. It is consequently limited to the address space, code, data and execution rights of its [[Processes|parent process]].<br />
<br />
A thread is characterized by :<br />
* an internal thread ID (ITID) and global thread id (GTID)<br />
* a task state segment (TSS) containing CPU state (registers, stack, ...)<br />
* scheduling data (priority flag, counter of total and remaining active time...)<br />
* a list of events related to the thread<br />
<br />
Threads are managed by the TSI module ''(Threads System Interface)''.<br />
<br />
== Threads System Interface (TSI) ==<br />
<br />
Each process is defined by a <code>TSI_ENTRY</code> containing all thread information.<br />
<br />
=== Thread ID (iTID and TID) ===<br />
<br />
An internal thread ID (iTID) is a 16-bit unsigned integer, uniquely assigned to each thread in the whole system, with a maximum of <code>TSI_MAX_THREADS</code>. The global thread ID (TID) is a 32-bit unsigned integer composed of the PID in the 16 upper bits, and of the ITID in the 16 lower bits.<br />
<br />
TSI maintains a linked list of unsorted used and free iTIDs, allowing allocation and release of iTIDs in ''O(1)'', by respectively removing or adding the iTID at the beginning of the list.<br />
Both list share the same global table called <code>StatusTable</code> with two initial pointers, one for the linked list of free entries (<code>firstFreeEntry</code>), one for the linked list of used entries (<code>firstUsedEntry</code>).<br />
<br />
Internal functions for iTID management are : <br />
* iTID TSI_AllocateTID(TSI_ENTRY *)<br />
* void TSI_ReleaseTID(iTID)<br />
<br />
To get the TSI_ENTRY for a specific iTID, an index table called <code>TSI_QuickTable</code> is maintained.</div>Kindmanhttp://wiki.amc-os.com/index.php?title=Threads&diff=101Threads2020-07-29T15:24:44Z<p>Kindman: </p>
<hr />
<div>== Thread definition in AMC-OS ==<br />
<br />
A thread is an execution unit running in the context of a specific [[Processes|process]]. It is consequently limited to the address space, code, data and execution rights of its [[Processes|parent process]].<br />
<br />
A thread is characterized by :<br />
* an internal thread ID (ITID) and global thread id (GTID)<br />
* a task state segment (TSS) containing CPU state (registers, stack, ...)<br />
* scheduling data (priority flag, counter of total and remaining active time...)<br />
* a list of events related to the thread<br />
<br />
Threads are managed by the TSI module ''(Threads System Interface)''.<br />
<br />
== Threads System Interface (TSI) ==<br />
<br />
Each process is defined by a <code>TSI_ENTRY</code> containing all thread information.<br />
<br />
=== Thread ID (ITID and GTID) ===<br />
<br />
An internal thread ID (ITID) is a 16-bit unsigned integer, uniquely assigned to each thread in the whole system, with a maximum of <code>TSI_MAX_THREADS</code>. The global thread ID (GTID) is a 32-bit unsigned integer composed of the PID in the 16 upper bits, and of the ITID in the 16 lower bits.<br />
<br />
TSI maintains a linked list of unsorted used and free TIDs, allowing allocation and release of TIDs in ''O(1)'', by respectively removing or adding the TID at the beginning of the list.<br />
Both list share the same global table called <code>StatusTable</code> with two initial pointers, one for the linked list of free entries (<code>firstFreeEntry</code>), one for the linked list of used entries (<code>firstUsedEntry</code>).<br />
<br />
Internal functions for TID management are : <br />
* ITID TSI_AllocateTID(TSI_ENTRY *)<br />
* void TSI_ReleaseTID(ITID)<br />
<br />
To get the TSI_ENTRY for a specific ITID, an index table called <code>TSI_QuickTable</code> is maintained.</div>Kindmanhttp://wiki.amc-os.com/index.php?title=Threads&diff=100Threads2020-07-29T15:19:36Z<p>Kindman: Created page with "A thread is an execution unit running in the context of a specific process. It is consequently limited to the address space, code, data and execution rights of i..."</p>
<hr />
<div>A thread is an execution unit running in the context of a specific [[Processes|process]]. It is consequently limited to the address space, code, data and execution rights of its [[Processes|parent process]].<br />
<br />
A thread is characterized by :<br />
* a task state segment (TSS) containing CPU state (registers, stack, ...)<br />
* scheduling data (priority flag, counter of total and remaining active time...)<br />
* a list of events related to the thread<br />
<br />
Threads are managed by the TSI module ''(Threads System Interface)''.<br />
<br />
== Threads System Interface (TSI) ==</div>Kindmanhttp://wiki.amc-os.com/index.php?title=Processes&diff=99Processes2020-07-29T14:50:53Z<p>Kindman: </p>
<hr />
<div>== Process definition in AMC-OS ==<br />
<br />
A process is an instance of an [[Applications|application]].<br />
Processes are managed in AMC-OS by the PSI ''(Processes System Interface)'' module.<br />
<br />
It is characterized by :<br />
* a process ID ''(PID)'' and its parent process ID<br />
* an owner ''(User ID)''<br />
* a list of execution [[Threads|threads]]<br />
* a page directory defining the address space used by all execution threads<br />
* all resource handles shared by all threads in the process.<br />
<br />
== PSI (Processes System Interface) ==<br />
<br />
Each process is defined by a <code>PSI_ENTRY</code> containing all process information.<br />
<br />
=== PID ===<br />
<br />
A PID is a 16-bit unsigned integer, uniquely assigned to each process, with a maximum of <code>PSI_MAX_PROCESSES</code>.<br />
PSI maintains a linked list of unsorted used and free PIDs, allowing allocation and release of PIDs in ''O(1)'', by respectively removing or adding the PID at the beginning of the list.<br />
Both list share the same global table called <code>StatusTable</code> with two initial pointers, one for the linked list of free entries (<code>firstFreeEntry</code>), one for the linked list of used entries (<code>firstUsedEntry</code>).<br />
<br />
Internal functions for PID management are : <br />
* PID PSI_AllocatePID(PSI_ENTRY *)<br />
* void PSI_ReleasePID(PID)<br />
<br />
To get the PSI_ENTRY for a specific PID, an index table called <code>PSI_QuickTable</code> is maintained.</div>Kindmanhttp://wiki.amc-os.com/index.php?title=Processes&diff=98Processes2020-07-29T14:49:41Z<p>Kindman: Created page with "== Process definition in AMC-OS == A process is an instance of an application. Processes are managed in AMC-OS by the PSI ''(Processes System Interface)'' mo..."</p>
<hr />
<div>== Process definition in AMC-OS ==<br />
<br />
A process is an instance of an [[Applications|application]].<br />
Processes are managed in AMC-OS by the PSI ''(Processes System Interface)'' module.<br />
<br />
It is characterized by :<br />
* a process ID ''(PID)'' and its parent process ID<br />
* an owner ''(User ID)''<br />
* a list of execution [[Threads|threads]]<br />
* a page directory defining the address space used by all execution threads<br />
* all resource handles shared by all threads in the process.<br />
<br />
== PSI (Processes System Interface) ==<br />
<br />
Each process is defined by a <code>PSI_ENTRY</code> containing all process information.<br />
<br />
=== PID ===<br />
<br />
A PID is a 16-bit unsigned integer, uniquely assigned to each process, with a maximum of <code>PSI_MAX_PROCESSES</code>.<br />
PSI maintains a linked list of unsorted used and free PIDs, allowing allocation and release of PIDs in ''O(1)'', by respectively removing or adding the PID at the beginning of the list.<br />
Both list share the same global table called <code>StatusTable</code> with two initial pointers, one for the linked list of free entries (<code>firstFreeEntry</code>), one for the linked list of used entries (<code>firstUsedEntry</code>).<br />
<br />
Internal functions for PID management are : <br />
<code><br />
PID PSI_AllocatePID(PSI_ENTRY *)<br />
void PSI_ReleasePID(PID)<br />
</code><br />
<br />
To get the PSI_ENTRY for a specific PID, an index table called <code>PSI_QuickTable</code> is maintained.</div>Kindmanhttp://wiki.amc-os.com/index.php?title=Applications,_processes_and_threads&diff=97Applications, processes and threads2020-07-29T14:09:26Z<p>Kindman: </p>
<hr />
<div>Execution tasks in AMC-OS are divided in [[Applications|applications]], [[Processes|processes]] and [[Threads|threads]] : <br />
<br />
* [[Applications|An application]] is a static combination of executable code and data, in AMCX format.<br />
* [[Processes|A process]] is an independant instance of an application.<br />
* [[Threads|A thread]] is an instance of an execution flow in the restricted context of a process.</div>Kindmanhttp://wiki.amc-os.com/index.php?title=Applications,_processes_and_threads&diff=96Applications, processes and threads2020-07-29T14:09:17Z<p>Kindman: </p>
<hr />
<div>Execution tasks in AMC-OS are divided in [[Applications|applications]], [[Processes|processes] and [[Threads|threads]] : <br />
<br />
* [[Applications|An application]] is a static combination of executable code and data, in AMCX format.<br />
* [[Processes|A process]] is an independant instance of an application.<br />
* [[Threads|A thread]] is an instance of an execution flow in the restricted context of a process.</div>Kindmanhttp://wiki.amc-os.com/index.php?title=Applications,_processes_and_threads&diff=95Applications, processes and threads2020-07-29T14:07:46Z<p>Kindman: Created page with "Execution tasks in AMC-OS are divided in applications, processes and threads : * An application is a static combination of executable code and data, in AMCX format. * A proc..."</p>
<hr />
<div>Execution tasks in AMC-OS are divided in applications, processes and threads : <br />
<br />
* An application is a static combination of executable code and data, in AMCX format.<br />
* A process is an independant instance of an application.<br />
* A thread is an instance of an execution flow in the restricted context of the process.</div>Kindmanhttp://wiki.amc-os.com/index.php?title=Main_Page&diff=94Main Page2020-07-29T13:50:16Z<p>Kindman: </p>
<hr />
<div>[[File:Amc-os_ant_final.png|top|right|frame|AMC-OS Logo]]<br />
<br />
==Welcome to AMC-OS Developers Website==<br />
<br />
The AMC-OS Developers Website provides resources and information for people who :<br />
* want to support AMC-OS development<br />
* want to understand better how computers and OS work<br />
* look for documentation and tools to build their own system<br />
The website is divided into several sections depending on the information you are looking for.<br />
<br />
To get general information on AMC-OS, please visit the [http://www.amc-os.com/ main website].<br />
<br />
All AMC-OS code and documentation is released under the [[AMC-OS Developers:General disclaimer|AMC-OS License]]<br />
<br />
{| class="wikitable" cellpadding="5" width="60%"<br />
|+ AMC-OS Developers Website sections<br />
! scope="col" | OS Design<br />
! scope="col" | Hardware<br />
! scope="col" | Running AMC-OS<br />
|- style="vertical-align:top;"<br />
|<br />
* [[Processor management]]<br />
* [[Boot process]]<br />
* [[AMCX file format]]<br />
* [[Memory and paging]]<br />
* [[Applications, processes and threads]]<br />
* [[Device drivers]]<br />
|<br />
* CPU<br />
** [[Intel x86 Architecture]]<br />
** [[Identifying CPU]]<br />
* [[Interrupts]] (PIC, APIC)<br />
* Devices identification<br />
** [[BIOS]]<br />
** [[Plug & Play]]<br />
** [[PCI]]<br />
* I/O<br />
** [[Floppy disk controller]]<br />
** [[IDE (ATA/ATAPI) controller]]<br />
|<br />
* [[Compiling and Linking]]<br />
* [[Installing and running]]<br />
* [[Debugging]]<br />
|-<br />
! scope="col" | Building software<br />
! scope="col" | Tools and resources<br />
! scope="col" |<br />
|- style="vertical-align:top;"<br />
|<br />
* [[AMC-OS Kernel API]]<br />
* [[AMC-OS C Library]]<br />
* [[Compiling and Linking]]<br />
|<br />
|<br />
|}</div>Kindmanhttp://wiki.amc-os.com/index.php?title=Memory_initialization&diff=93Memory initialization2020-04-18T16:47:37Z<p>Kindman: </p>
<hr />
<div>=During AMC-OS Loader=<br />
<br />
To get size and map of memory, AMC-OS Loader now relies mainly on BIOS instead of probing, which was the preferred way in AMC-OS <2.10.<br />
<br />
AMC-OS Loader proceed this way :<br />
* Try INT 15H, function E820 to get memory map.<br />
* Try INT 15H, function E801 to get size of memory below 16MB and above 16MB<br />
* Try INT 15H, function 88 to get effective size of extended memory<br />
* Get configured size of extended memory in CMOS<br />
<br />
Depending on functions supported by BIOS, map will be more or less precise, and memory might be lost if ISA Hole in the 15-16M area is configured.<br />
<br />
=Kernel start=<br />
<br />
When Kernel starts, AMC-OS uses information discovered by the loader to build memory structures.<br />
<br />
==First megabyte==<br />
Kernel starts by calling <code>INIT_MemoryUsableIn1stMeg</code>. The function determines the first address of free memory in the first megabyte, just after kernel relocation code and below EBDA.<br />
<br />
The function fills :<br />
* <code>MEMORY_FreePageAddrIn1stMeg</code><br />
* <code>MEMORY_FreePagesIn1stMeg</code><br />
<br />
==A20 Gate==<br />
Kernel unlocks A20 gate by calling <code>INIT_A20Gate</code>.<br />
<br />
A20 gate was controlled by keyboard controller on AT+. To allow compatibility with 8086/8088, the A20 address line was forced to 0 on AT computers, blocking access to memory above 1MB. A20 gate must be enabled to allow A20 address line to be used normally.<br />
<br />
==Physical memory initialization==<br />
Physical memory is initialized by calling <code>INIT_GlobalMemory</code>.<br />
<br />
===Memory map===<br />
The function first builds a map of physical memory :<br />
* If available, it relies first on type-1 (available) entries of E820 BIOS records. ''In current release, memory above 4GB is ignored''.<br />
* If available, it relies on E801 BIOS call results to determine a block of memory below 16MB and a block of memory above 16MB.<br />
* In other cases, kernel do a manual probing of available memory, using function <code>INIT_MemoryCheckSegment</code>.</div>Kindmanhttp://wiki.amc-os.com/index.php?title=Memory_initialization&diff=92Memory initialization2020-04-18T16:39:49Z<p>Kindman: </p>
<hr />
<div>=During AMC-OS Loader=<br />
<br />
To get size and map of memory, AMC-OS Loader now relies mainly on BIOS instead of probing, which was the preferred way in AMC-OS <2.10.<br />
<br />
AMC-OS Loader proceed this way :<br />
* Try INT 15H, function E820 to get memory map.<br />
* Try INT 15H, function E801 to get size of memory below 16MB and above 16MB<br />
* Try INT 15H, function 88 to get effective size of extended memory<br />
* Get configured size of extended memory in CMOS<br />
<br />
Depending on functions supported by BIOS, map will be more or less precise, and memory might be lost if ISA Hole in the 15-16M area is configured.<br />
<br />
=Kernel start=<br />
<br />
When Kernel starts, AMC-OS uses information discovered by the loader to build memory structures.<br />
<br />
==First megabyte==<br />
Kernel starts by calling <code>INIT_MemoryUsableIn1stMeg</code>. The function determines the first address of free memory in the first megabyte, just after kernel relocation code and below EBDA.<br />
<br />
The function fills :<br />
* <code>MEMORY_FreePageAddrIn1stMeg</code><br />
* <code>MEMORY_FreePagesIn1stMeg</code><br />
<br />
==A20 Gate==<br />
Kernel unlocks A20 gate by calling <code>INIT_A20Gate</code>.<br />
<br />
A20 gate was controlled by keyboard controller on AT+. To allow compatibility with 8086/8088, the A20 address line was forced to 0 on AT computers, blocking access to memory above 1MB. A20 gate must be enabled to allow A20 address line to be used normally.</div>Kindmanhttp://wiki.amc-os.com/index.php?title=Memory_and_paging&diff=91Memory and paging2020-04-18T16:04:37Z<p>Kindman: </p>
<hr />
<div>= Physical memory management =<br />
For more information on physical memory initialization, refer to ''[[Memory initialization]]'' article.<br />
<br />
== Memory areas ==<br />
<br />
After scanning the linear address space for available physical memory, AMC-OS split the physical memory in two areas :<br />
* The '''low memory area''' must be at least 4Mbytes large, and its size is proportional to the total amount of physical memory available. This area is also referred as ''kernel memory'' as the physical memory is available from all page directories at kernel privilege.<br />
* The '''high memory area''' contains all the remaining memory and is used for user memory.<br />
<br />
Each memory area is divided in blocks of 256Kbytes, and is specified in a <tt>MEMORY_AREA</tt> structure containing :<br />
* the number and pointers to the used blocks they contain;<br />
* the number and pointers to the free blocks they contain;<br />
* the number and pointers to the free pages.<br />
<br />
User memory can be taken from low memory if high memory is exhausted.<br />
<br />
== Blocks management ==<br />
=== Free blocks list ===<br />
<br />
By default, each memory area is divided in blocks of 256 Kbytes. A new block is ''activated'' and divided in free pages, if there are no more free pages available in the area. Free blocks are stored in the ''free blocks list'', a linked list of the '''InactiveMemory''' structure. It contains :<br />
* the pointer to the free block;<br />
* the number of contiguous free blocks;<br />
* the pointer to the next structure.<br />
During initialization phase, we pre-allocate the maximum of free blocks structures that can be necessary, ie half the number of blocks. This list of free blocks structures is also a linked list to accelerate allocating and freeing processes.<br />
<br />
The pointer to the free blocks list is stored in <tt>MEMORY_AREA.ptrFreeBlocks</tt>, and count in <tt>MEMORY_AREA.nbFreeBlocks</tt>.<br />
<br />
The pointer to the free blocks structures list is stored in <tt>MEMORY_ptrInactiveFreeBlocksStruct</tt>, and count in <tt>MEMORY_nbInactiveFreeBlocksStruct</tt>.<br />
<br />
=== Number of free pages per block ===<br />
<br />
A free pages per block table is created to be able to put back in free blocks list a block that has all its pages free.<br />
It is a simple table indexed by the block number, containing for each entry an unsigned byte with the number of free pages. Obviously, there can't be more than 256 pages per block (64 by default).</div>Kindmanhttp://wiki.amc-os.com/index.php?title=Memory_and_paging&diff=90Memory and paging2020-04-18T15:59:07Z<p>Kindman: </p>
<hr />
<div>== Physical memory management ==<br />
For more information on physical memory initialization, refer to ''[[Memory initialization]]'' article.<br />
<br />
=== Memory areas ===<br />
<br />
After scanning the linear address space for available physical memory, AMC-OS split the physical memory in two areas :<br />
* The '''low memory area''' must be at least 4Mbytes large, and its size is proportional to the total amount of physical memory available. This area is also referred as ''kernel memory'' as the physical memory is available from all page directories at kernel privilege.<br />
* The '''high memory area''' contains all the remaining memory and is used for user memory.<br />
<br />
Each area is specified in a <tt>MEMORY_AREA</tt> structure. It contains :<br />
* the number and pointers to the used blocks they contain;<br />
* the number and pointers to the free blocks they contain;<br />
* the number and pointers to the free pages.<br />
<br />
User memory can be taken from low memory if high memory is exhausted.<br />
<br />
=== Free blocks list ===<br />
<br />
By default, each memory area is divided in blocks of 256 Kbytes. A new block is ''activated'' and divided in free pages, if there are no more free pages available in the area. Free blocks are stored in the ''free blocks list'', a linked list of the '''InactiveMemory''' structure. It contains :<br />
* the pointer to the free block;<br />
* the number of contiguous free blocks;<br />
* the pointer to the next structure.<br />
During initialization phase, we pre-allocate the maximum of free blocks structures that can be necessary, ie half the number of blocks. This list of free blocks structures is also a linked list to accelerate allocating and freeing processes.<br />
<br />
The pointer to the free blocks list is stored in <tt>MEMORY_AREA.ptrFreeBlocks</tt>, and count in <tt>MEMORY_AREA.nbFreeBlocks</tt>.<br />
<br />
The pointer to the free blocks structures list is stored in <tt>MEMORY_ptrInactiveFreeBlocksStruct</tt>, and count in <tt>MEMORY_nbInactiveFreeBlocksStruct</tt>.<br />
<br />
=== Number of free pages per block ===<br />
<br />
A free pages per block table is created to be able to put back in free blocks list a block that has all its pages free.<br />
It is a simple table indexed by the block number, containing for each entry an unsigned byte with the number of free pages. Obviously, there can't be more than 256 pages per block (64 by default).</div>Kindmanhttp://wiki.amc-os.com/index.php?title=Memory_and_paging&diff=89Memory and paging2020-04-18T15:58:43Z<p>Kindman: </p>
<hr />
<div><br />
== Memory model ==<br />
<br />
=== Physical memory ===<br />
<br />
Physical memory is divided in several segments that can be used by the system.<br />
During initialization phase, the system scan the linear address space for the available segments. In a standard PC, there are typically two segments : the first megabyte of memory (generally only the first 640Kbytes as BIOS, ROMs and video memory are mapped in the last 384Kbytes) and the memory above 1MB. In some cases, there also can be a hole in the 15-16M adressing space, or memory reserved for PCI addressing space. During the scan, the system counts the number of available blocks in each segment.<br />
<br />
AMC-OS split the physical memory in two areas :<br />
* low memory reserved for kernel usage (''will also be referred as '''kernel memory''')'';<br />
* high memory for processes ''(will also be referred as '''user memory''')''. <br />
These two areas are divided in contiguous blocks of 256Kbytes by default, themselves being divided in 4Kbytes pages. To reduce the amount of memory used by the system, the blocks are activated on demand, and only then divided in pages.<br />
<br />
=== Virtual memory ===<br />
<br />
<br />
<br />
== Physical memory management ==<br />
For more information on physical memory initialization, refer to ''[[Memory initialization]]'' article.<br />
<br />
=== Memory areas ===<br />
<br />
After scanning the linear address space for available physical memory, AMC-OS split the physical memory in two areas :<br />
* The '''low memory area''' must be at least 4Mbytes large, and its size is proportional to the total amount of physical memory available. This area is also referred as ''kernel memory'' as the physical memory is available from all page directories at kernel privilege.<br />
* The '''high memory area''' contains all the remaining memory and is used for user memory.<br />
<br />
Each area is specified in a <tt>MEMORY_AREA</tt> structure. It contains :<br />
* the number and pointers to the used blocks they contain;<br />
* the number and pointers to the free blocks they contain;<br />
* the number and pointers to the free pages.<br />
<br />
User memory can be taken from low memory if high memory is exhausted.<br />
<br />
=== Free blocks list ===<br />
<br />
By default, each memory area is divided in blocks of 256 Kbytes. A new block is ''activated'' and divided in free pages, if there are no more free pages available in the area. Free blocks are stored in the ''free blocks list'', a linked list of the '''InactiveMemory''' structure. It contains :<br />
* the pointer to the free block;<br />
* the number of contiguous free blocks;<br />
* the pointer to the next structure.<br />
During initialization phase, we pre-allocate the maximum of free blocks structures that can be necessary, ie half the number of blocks. This list of free blocks structures is also a linked list to accelerate allocating and freeing processes.<br />
<br />
The pointer to the free blocks list is stored in <tt>MEMORY_AREA.ptrFreeBlocks</tt>, and count in <tt>MEMORY_AREA.nbFreeBlocks</tt>.<br />
<br />
The pointer to the free blocks structures list is stored in <tt>MEMORY_ptrInactiveFreeBlocksStruct</tt>, and count in <tt>MEMORY_nbInactiveFreeBlocksStruct</tt>.<br />
<br />
=== Number of free pages per block ===<br />
<br />
A free pages per block table is created to be able to put back in free blocks list a block that has all its pages free.<br />
It is a simple table indexed by the block number, containing for each entry an unsigned byte with the number of free pages. Obviously, there can't be more than 256 pages per block (64 by default).</div>Kindmanhttp://wiki.amc-os.com/index.php?title=Memory_and_paging&diff=88Memory and paging2020-04-18T15:29:45Z<p>Kindman: </p>
<hr />
<div><br />
== Memory model ==<br />
<br />
=== Physical memory ===<br />
<br />
Physical memory is divided in several segments that can be used by the system.<br />
During initialization phase, the system scan the linear address space for the available segments. In a standard PC, there are typically two segments : the first megabyte of memory (generally only the first 640Kbytes as BIOS, ROMs and video memory are mapped in the last 384Kbytes) and the memory above 1MB. In some cases, there also can be a hole in the 15-16M adressing space, or memory reserved for PCI addressing space. During the scan, the system counts the number of available blocks in each segment.<br />
<br />
AMC-OS split the physical memory in two areas :<br />
* low memory reserved for kernel usage (''will also be referred as '''kernel memory''')'';<br />
* high memory for processes ''(will also be referred as '''user memory''')''. <br />
These two areas are divided in contiguous blocks of 256Kbytes by default, themselves being divided in 4Kbytes pages. To reduce the amount of memory used by the system, the blocks are activated on demand, and only then divided in pages.<br />
<br />
=== Virtual memory ===<br />
<br />
<br />
<br />
== Physical memory management ==<br />
For more information on physical memory initialization, refer to [[Memory Initialization]] article.<br />
<br />
=== Memory areas ===<br />
<br />
After scanning the linear address space for available physical memory, AMC-OS split the physical memory in two areas :<br />
* The '''low memory area''' must be at least 4Mbytes large, and its size is proportional to the total amount of physical memory available. This area is also referred as ''kernel memory'' as the physical memory is available from all page directories at kernel privilege.<br />
* The '''high memory area''' contains all the remaining memory and is used for user memory.<br />
<br />
Each area is specified in a <tt>MEMORY_AREA</tt> structure. It contains :<br />
* the number and pointers to the used blocks they contain;<br />
* the number and pointers to the free blocks they contain;<br />
* the number and pointers to the free pages.<br />
<br />
User memory can be taken from low memory if high memory is exhausted.<br />
<br />
=== Free blocks list ===<br />
<br />
By default, each memory area is divided in blocks of 256 Kbytes. A new block is ''activated'' and divided in free pages, if there are no more free pages available in the area. Free blocks are stored in the ''free blocks list'', a linked list of the '''InactiveMemory''' structure. It contains :<br />
* the pointer to the free block;<br />
* the number of contiguous free blocks;<br />
* the pointer to the next structure.<br />
During initialization phase, we pre-allocate the maximum of free blocks structures that can be necessary, ie half the number of blocks. This list of free blocks structures is also a linked list to accelerate allocating and freeing processes.<br />
<br />
The pointer to the free blocks list is stored in <tt>MEMORY_AREA.ptrFreeBlocks</tt>, and count in <tt>MEMORY_AREA.nbFreeBlocks</tt>.<br />
<br />
The pointer to the free blocks structures list is stored in <tt>MEMORY_ptrInactiveFreeBlocksStruct</tt>, and count in <tt>MEMORY_nbInactiveFreeBlocksStruct</tt>.<br />
<br />
=== Number of free pages per block ===<br />
<br />
A free pages per block table is created to be able to put back in free blocks list a block that has all its pages free.<br />
It is a simple table indexed by the block number, containing for each entry an unsigned byte with the number of free pages. Obviously, there can't be more than 256 pages per block (64 by default).</div>Kindmanhttp://wiki.amc-os.com/index.php?title=Memory_and_paging&diff=87Memory and paging2020-04-18T15:29:27Z<p>Kindman: /* Physical memory management */</p>
<hr />
<div><br />
== Memory model ==<br />
<br />
=== Physical memory ===<br />
<br />
Physical memory is divided in several segments that can be used by the system.<br />
During initialization phase, the system scan the linear address space for the available segments. In a standard PC, there are typically two segments : the first megabyte of memory (generally only the first 640Kbytes as BIOS, ROMs and video memory are mapped in the last 384Kbytes) and the memory above 1MB. In some cases, there also can be a hole in the 15-16M adressing space, or memory reserved for PCI addressing space. During the scan, the system counts the number of available blocks in each segment.<br />
<br />
AMC-OS split the physical memory in two areas :<br />
* low memory reserved for kernel usage (''will also be referred as '''kernel memory''')'';<br />
* high memory for processes ''(will also be referred as '''user memory''')''. <br />
These two areas are divided in contiguous blocks of 256Kbytes by default, themselves being divided in 4Kbytes pages. To reduce the amount of memory used by the system, the blocks are activated on demand, and only then divided in pages.<br />
<br />
=== Virtual memory ===<br />
<br />
<br />
<br />
== Physical memory management ==<br />
For more information on physical memory initialization, refer to [[Memmory Initialization]] article.<br />
<br />
=== Memory areas ===<br />
<br />
After scanning the linear address space for available physical memory, AMC-OS split the physical memory in two areas :<br />
* The '''low memory area''' must be at least 4Mbytes large, and its size is proportional to the total amount of physical memory available. This area is also referred as ''kernel memory'' as the physical memory is available from all page directories at kernel privilege.<br />
* The '''high memory area''' contains all the remaining memory and is used for user memory.<br />
<br />
Each area is specified in a <tt>MEMORY_AREA</tt> structure. It contains :<br />
* the number and pointers to the used blocks they contain;<br />
* the number and pointers to the free blocks they contain;<br />
* the number and pointers to the free pages.<br />
<br />
User memory can be taken from low memory if high memory is exhausted.<br />
<br />
=== Free blocks list ===<br />
<br />
By default, each memory area is divided in blocks of 256 Kbytes. A new block is ''activated'' and divided in free pages, if there are no more free pages available in the area. Free blocks are stored in the ''free blocks list'', a linked list of the '''InactiveMemory''' structure. It contains :<br />
* the pointer to the free block;<br />
* the number of contiguous free blocks;<br />
* the pointer to the next structure.<br />
During initialization phase, we pre-allocate the maximum of free blocks structures that can be necessary, ie half the number of blocks. This list of free blocks structures is also a linked list to accelerate allocating and freeing processes.<br />
<br />
The pointer to the free blocks list is stored in <tt>MEMORY_AREA.ptrFreeBlocks</tt>, and count in <tt>MEMORY_AREA.nbFreeBlocks</tt>.<br />
<br />
The pointer to the free blocks structures list is stored in <tt>MEMORY_ptrInactiveFreeBlocksStruct</tt>, and count in <tt>MEMORY_nbInactiveFreeBlocksStruct</tt>.<br />
<br />
=== Number of free pages per block ===<br />
<br />
A free pages per block table is created to be able to put back in free blocks list a block that has all its pages free.<br />
It is a simple table indexed by the block number, containing for each entry an unsigned byte with the number of free pages. Obviously, there can't be more than 256 pages per block (64 by default).</div>Kindmanhttp://wiki.amc-os.com/index.php?title=Memory_initialization&diff=86Memory initialization2020-04-18T15:28:51Z<p>Kindman: Created page with "==During AMC-OS Loader== To get size and map of memory, AMC-OS Loader now relies mainly on BIOS instead of probing, which was the preferred way in AMC-OS <2.10. AMC-OS Loade..."</p>
<hr />
<div>==During AMC-OS Loader==<br />
<br />
To get size and map of memory, AMC-OS Loader now relies mainly on BIOS instead of probing, which was the preferred way in AMC-OS <2.10.<br />
<br />
AMC-OS Loader proceed this way :<br />
* Try INT 15H, function E820 to get memory map.<br />
* Try INT 15H, function E801 to get size of memory below 16MB and above 16MB<br />
* Try INT 15H, function 88 to get effective size of extended memory<br />
* Get configured size of extended memory in CMOS<br />
<br />
Depending on functions supported by BIOS, map will be more or less precise, and memory might be lost if ISA Hole in the 15-16M area is configured.<br />
<br />
==Kernel start==</div>Kindmanhttp://wiki.amc-os.com/index.php?title=AMC-OS_Loader&diff=85AMC-OS Loader2020-04-18T15:28:37Z<p>Kindman: </p>
<hr />
<div>==Introduction==<br />
<br />
AMC-OS Loader is a module part of the [[Boot process|boot process]]. Its task is to locate the kernel in the booting volume, load it in memory and prepare all the necessary structures to start it.<br />
<br />
AMC-OS Loader gives us much more flexibility in [[Boot process|boot process]], as we no longer have the limitation of 512 bytes of code. However, the CPU is still running in real mode, implying limitations in the size of structures and files we have to manipulate.<br />
<br />
==Process==<br />
[[image:Amcos_loader.png|right|thumb|250px|AMC-OS Loader splash screen]]<br />
AMC-OS Loader follow this procedure :<br />
* Wait for options (typically F1 for debugging purposes if compiled with DEBUG support)<br />
* System check : Check that we have a 386+ running in real-mode<br />
* [[AMC-OS Loader Memory management|Check for EBDA and initialize first MB of memory to allow memory allocation]]<br />
* [[Memory initialization|Ask BIOS information on the available RAM in the system]]<br />
* Precisely [[Identifying CPU|identify the CPU]] using either the CPUID instruction or a CPU reset, and calculates its running frequency<br />
* Check if we start from a MBR (removeable media) or a VBR and locate volume to boot<br />
* Identify the volume type (FAT12, FAT16...) and initialize according filesystem driver.<br />
* Locate and load the required kernel files<br />
* Identify the video graphics card, check VESA support to get best text resolution during kernel initialization<br />
* Prepare the CPU for protected mode (GDT and system descriptors)<br />
* Do a first switch to protected mode to decode kernel AMCX file and relocate it in memory<br />
* Do a second switch to protected mode to start kernel<br />
<br />
==Files==<br />
AMC-OS Loader is composed of two files :<br />
* <tt>AMCOSLDR.SYS</tt> contains raw code of AMC-OS Loader (no header nor relocation).<br />
* <tt>AMCOSLDR.IMG</tt> is a picture of AMC-OS Logo displayed during AMC-OS Loader execution.<br />
<br />
Both files are loaded by the [[Boot process#The Boot Loader|boot sector]].<br />
<br />
==16-bit code and V86==<br />
AMC-OS Loader stays in memory to allow 16-bit code to be executed from Kernel in V86 mode, typically to call INT 10H (video)</div>Kindmanhttp://wiki.amc-os.com/index.php?title=Memory_identification&diff=84Memory identification2020-04-18T15:28:18Z<p>Kindman: Blanked the page</p>
<hr />
<div></div>Kindmanhttp://wiki.amc-os.com/index.php?title=AMC-OS_Loader_Memory_management&diff=83AMC-OS Loader Memory management2020-04-13T15:51:09Z<p>Kindman: </p>
<hr />
<div>=Memory used during AMC-OS Loader execution=<br />
AMC-OS Loader uses only the first megabyte of memory :<br />
{|-<br />
|<code>00000-003FF</code><br />
|Real-mode interrupt table<br />
|-<br />
|<code>00400-00500</code><br />
|BIOS static data<br />
|-<br />
|<code>00501-005FF</code><br />
|Free (unused)<br />
|-<br />
|<code>00600-007FF</code><br />
|''Master boot record''<br />
|-<br />
|<code>00800-[__A]</code><br />
|Kernel static data (initialized by boot loader)<br />
|-<br />
|<code>[__A]-[__B]</code><br />
|AMC-OS Loader code<br />
|-<br />
|<code>[__B]-[__C]</code><br />
|AMC-OS Loader picture<br />
|-<br />
|<code>[__C]-077FF</code><br />
|''Free for allocation''<br />
|-<br />
|<code>077FF-07BFF</code><br />
|AMC-OS Loader stack<br />
|-<br />
|<code>07C00-07DFF</code><br />
|Boot loader code (VBR or MBR for floppy disk)<br />
|-<br />
|<code>07E00-07FFF</code><br />
|Free (unused)<br />
|-<br />
|<code>08000-9[_D]</code><br />
|''Free for allocation''<br />
|-<br />
|<code>9[_D]-09FFF</code><br />
|Extended BIOS data area (EBDA - optional)<br />
|}<br />
<br />
=Memory management=<br />
==Initialization==<br />
During memory initialization process (<code>AMCOSLDR_InitFirstMegabyte</code>), AMC-OS Loader :<br />
* looks for EBDA using interrupt 12H and value stored in 0040:000E to get highest pointer in memory [_D]<br />
* calculates the values of [__A] to get lowest pointer in memory<br />
* creates a linked list of available blocks of memory (AMCOSLDR_Malloc_Entry)<br />
* initializes two blocks of available memory (marked ''Free for allocation'' in previous table)<br />
<br />
==Allocation==<br />
Three functions are available to AMC-OS Loader for memory allocation :<br />
* <code>AMCOSLDR_DefinitiveAlloc</code> : Used to allocate memory that shall stay at this place at the end of the process (used by kernel afterwards). Memory will be taken from bottom of free memory.<br />
* <code>AMCOSLDR_TempAlloc</code> : Used to allocate memory that will be freed at the end of the process (eraseable by kernel afterwards). Memory will be taken from top of free memory.<br />
* <code>AMCOSLDR_VolatileAlloc</code> : Used to allocate memory for immediate use (valid only until a new call to any memory function is made). Memory will be taken from top of free memory.<br />
All functions waits for the requested size in segment size (16-bytes unit), and returns a segment of memory aligned on 512 bytes boundaries to facilitate disk operations.<br />
<br />
The two first functions maintains the linked list of available blocks of memory.</div>Kindmanhttp://wiki.amc-os.com/index.php?title=Memory_identification&diff=82Memory identification2020-04-13T15:24:19Z<p>Kindman: Created page with "==During AMC-OS Loader== To get size and map of memory, AMC-OS Loader now relies mainly on BIOS instead of probing, which was the preferred way in AMC-OS <2.10. AMC-OS Loade..."</p>
<hr />
<div>==During AMC-OS Loader==<br />
<br />
To get size and map of memory, AMC-OS Loader now relies mainly on BIOS instead of probing, which was the preferred way in AMC-OS <2.10.<br />
<br />
AMC-OS Loader proceed this way :<br />
* Try INT 15H, function E820 to get memory map.<br />
* Try INT 15H, function E801 to get size of memory below 16MB and above 16MB<br />
* Try INT 15H, function 88 to get effective size of extended memory<br />
* Get configured size of extended memory in CMOS<br />
<br />
Depending on functions supported by BIOS, map will be more or less precise, and memory might be lost if ISA Hole in the 15-16M area is configured.<br />
<br />
==Kernel start==</div>Kindmanhttp://wiki.amc-os.com/index.php?title=AMC-OS_Loader&diff=81AMC-OS Loader2020-04-13T15:19:17Z<p>Kindman: </p>
<hr />
<div>==Introduction==<br />
<br />
AMC-OS Loader is a module part of the [[Boot process|boot process]]. Its task is to locate the kernel in the booting volume, load it in memory and prepare all the necessary structures to start it.<br />
<br />
AMC-OS Loader gives us much more flexibility in [[Boot process|boot process]], as we no longer have the limitation of 512 bytes of code. However, the CPU is still running in real mode, implying limitations in the size of structures and files we have to manipulate.<br />
<br />
==Process==<br />
[[image:Amcos_loader.png|right|thumb|250px|AMC-OS Loader splash screen]]<br />
AMC-OS Loader follow this procedure :<br />
* Wait for options (typically F1 for debugging purposes if compiled with DEBUG support)<br />
* System check : Check that we have a 386+ running in real-mode<br />
* [[AMC-OS Loader Memory management|Check for EBDA and initialize first MB of memory to allow memory allocation]]<br />
* [[Memory identification|Ask BIOS information on the available RAM in the system]]<br />
* Precisely [[Identifying CPU|identify the CPU]] using either the CPUID instruction or a CPU reset, and calculates its running frequency<br />
* Check if we start from a MBR (removeable media) or a VBR and locate volume to boot<br />
* Identify the volume type (FAT12, FAT16...) and initialize according filesystem driver.<br />
* Locate and load the required kernel files<br />
* Identify the video graphics card, check VESA support to get best text resolution during kernel initialization<br />
* Prepare the CPU for protected mode (GDT and system descriptors)<br />
* Do a first switch to protected mode to decode kernel AMCX file and relocate it in memory<br />
* Do a second switch to protected mode to start kernel<br />
<br />
==Files==<br />
AMC-OS Loader is composed of two files :<br />
* <tt>AMCOSLDR.SYS</tt> contains raw code of AMC-OS Loader (no header nor relocation).<br />
* <tt>AMCOSLDR.IMG</tt> is a picture of AMC-OS Logo displayed during AMC-OS Loader execution.<br />
<br />
Both files are loaded by the [[Boot process#The Boot Loader|boot sector]].<br />
<br />
==16-bit code and V86==<br />
AMC-OS Loader stays in memory to allow 16-bit code to be executed from Kernel in V86 mode, typically to call INT 10H (video)</div>Kindmanhttp://wiki.amc-os.com/index.php?title=AMC-OS_Loader&diff=80AMC-OS Loader2020-04-13T15:17:59Z<p>Kindman: </p>
<hr />
<div>==Introduction==<br />
<br />
AMC-OS Loader is a module part of the [[Boot process|boot process]]. Its task is to locate the kernel in the booting volume, load it in memory and prepare all the necessary structures to start it.<br />
<br />
AMC-OS Loader gives us much more flexibility in [[Boot process|boot process]], as we no longer have the limitation of 512 bytes of code. However, the CPU is still running in real mode, implying limitations in the size of structures and files we have to manipulate.<br />
<br />
==Process==<br />
[[image:Amcos_loader.png|right|thumb|250px|AMC-OS Loader splash screen]]<br />
AMC-OS Loader follow this procedure :<br />
* Wait for options (typically F1 for debugging purposes if compiled with DEBUG support)<br />
* System check : Check that we have a 386+ running in real-mode<br />
* Check for EBDA and [[AMC-OS Loader Memory management|initialize first MB of memory to allow memory allocation]]<br />
* Ask BIOS information on the available RAM in the system.<br />
* Precisely [[Identifying CPU|identify the CPU]] using either the CPUID instruction or a CPU reset, and calculates its running frequency<br />
* Check if we start from a MBR (removeable media) or a VBR and locate volume to boot<br />
* Identify the volume type (FAT12, FAT16...) and initialize according filesystem driver.<br />
* Locate and load the required kernel files<br />
* Identify the video graphics card, check VESA support to get best text resolution during kernel initialization<br />
* Prepare the CPU for protected mode (GDT and system descriptors)<br />
* Do a first switch to protected mode to decode kernel AMCX file and relocate it in memory<br />
* Do a second switch to protected mode to start kernel<br />
<br />
==Files==<br />
AMC-OS Loader is composed of two files :<br />
* <tt>AMCOSLDR.SYS</tt> contains raw code of AMC-OS Loader (no header nor relocation).<br />
* <tt>AMCOSLDR.IMG</tt> is a picture of AMC-OS Logo displayed during AMC-OS Loader execution.<br />
<br />
Both files are loaded by the [[Boot process#The Boot Loader|boot sector]].<br />
<br />
==16-bit code and V86==<br />
AMC-OS Loader stays in memory to allow 16-bit code to be executed from Kernel in V86 mode, typically to call INT 10H (video)</div>Kindmanhttp://wiki.amc-os.com/index.php?title=AMC-OS_Loader_Memory_management&diff=79AMC-OS Loader Memory management2020-04-13T15:15:52Z<p>Kindman: </p>
<hr />
<div>=Memory used during AMC-OS Loader execution=<br />
AMC-OS Loader uses only the first megabyte of memory :<br />
{|-<br />
|<code>00000-003FF</code><br />
|Real-mode interrupt table<br />
|-<br />
|<code>00400-00500</code><br />
|BIOS static data<br />
|-<br />
|<code>00501-005FF</code><br />
|Free (unused)<br />
|-<br />
|<code>00600-007FF</code><br />
|''Master boot record''<br />
|-<br />
|<code>00800-[__A]</code><br />
|Kernel static data (initialized by boot loader)<br />
|-<br />
|<code>[__A]-[__B]</code><br />
|AMC-OS Loader code<br />
|-<br />
|<code>[__B]-[__C]</code><br />
|AMC-OS Loader picture<br />
|-<br />
|<code>[__C]-077FF</code><br />
|''Free for allocation''<br />
|-<br />
|<code>077FF-07BFF</code><br />
|AMC-OS Loader stack<br />
|-<br />
|<code>07C00-07DFF</code><br />
|Boot loader code (VBR or MBR for floppy disk)<br />
|-<br />
|<code>07E00-07FFF</code><br />
|Free (unused)<br />
|-<br />
|<code>08000-9[_D]</code><br />
|''Free for allocation''<br />
|-<br />
|<code>9[_D]-09FFF</code><br />
|Extended BIOS data area (EBDA - optional)<br />
|}<br />
<br />
=Memory management=<br />
==Initialization==<br />
During memory initialization process (<code>AMCOSLDR_InitFirstMegabyte</code>), AMC-OS Loader :<br />
* looks for EBDA using interrupt 12H and value stored in 0040:000E to get highest pointer in memory [_D]<br />
* calculates the values of [__A] to get lowest pointer in memory<br />
* creates a linked list of available blocks of memory (AMCOSLDR_Malloc_Entry)<br />
* initializes two blocks of available memory (marked ''Free for allocation'' in previous table)<br />
<br />
==Allocation==<br />
Three functions are available to AMC-OS Loader for memory allocation :<br />
* <code>AMCOSLDR_DefinitiveAlloc</code> : Used to allocate memory that shall stay at this place at the end of the process (used by kernel afterwards). Memory will be taken from bottom of free memory.<br />
* <code>AMCOSLDR_TempAlloc</code> : Used to allocate memory that will be freed at the end of the process (eraseable by kernel afterwards). Memory will be taken from top of free memory.<br />
* <code>AMCOSLDR_VolatileAlloc</code> : Used to allocate memory for immediate use (valid only until a new call to any memory function is made). Memory will be taken from top of free memory.<br />
All functions waits for the requested size in bytes (must be a multiple of 16), and returns a segment of memory aligned on 512 bytes boundaries to facilitate disk operations.<br />
<br />
The two first functions maintains the linked list of available blocks of memory.</div>Kindmanhttp://wiki.amc-os.com/index.php?title=AMC-OS_Loader_Memory_management&diff=78AMC-OS Loader Memory management2020-04-13T15:15:18Z<p>Kindman: </p>
<hr />
<div>=Memory used during AMC-OS Loader execution=<br />
AMC-OS Loader uses only the first megabyte of memory :<br />
{|-<br />
|<code>00000-003FF</code><br />
|Real-mode interrupt table<br />
|-<br />
|<code>00400-00500</code><br />
|BIOS static data<br />
|-<br />
|<code>00501-005FF</code><br />
|Free (unused)<br />
|-<br />
|<code>00600-007FF</code><br />
|''Master boot record''<br />
|-<br />
|<code>00800-[__A]</code><br />
|Kernel static data (initialized by boot loader)<br />
|-<br />
|<code>[__A]-[__B]</code><br />
|AMC-OS Loader code<br />
|-<br />
|<code>[__B]-[__C]</code><br />
|AMC-OS Loader picture<br />
|-<br />
|<code>[__C]-077FF</code><br />
|''Free for allocation''<br />
|-<br />
|<code>077FF-07BFF</code><br />
|AMC-OS Loader stack<br />
|-<br />
|<code>07C00-07DFF</code><br />
|Boot loader code (VBR or MBR for floppy disk)<br />
|-<br />
|<code>07E00-07FFF</code><br />
|Free (unused)<br />
|-<br />
|<code>08000-9[_D]</code><br />
|''Free for allocation''<br />
|-<br />
|<code>9[_D]-09FFF</code><br />
|Extended BIOS data area (EBDA - optional)<br />
|}<br />
<br />
=Memory management=<br />
==Initialization==<br />
During memory initialization process (<code>AMCOSLDR_InitFirstMegabyte</code>), AMC-OS Loader :<br />
* looks for EBDA using interrupt 12H and value stored in 0040:000E to get highest pointer in memory [_D]<br />
* calculates the values of [__A] to get lowest pointer in memory<br />
* creates a linked list of available blocks of memory (AMCOSLDR_Malloc_Entry)<br />
* initializes two blocks of available memory (marked ''Free for allocation'' in previous table)<br />
<br />
==Allocation==<br />
Three functions are available to AMC-OS Loader for memory allocation :<br />
* <code>AMCOSLDR_DefinitiveAlloc</code> : Used to allocate memory that shall stay at this place at the end of the process (used by kernel afterwards). Memory will be taken from bottom of free memory.<br />
* <code>AMCOSLDR_TempAlloc</code> : Used to allocate memory that will be freed at the end of the process (eraseable by kernel afterwards). Memory will be taken from top of free memory.<br />
* <code>AMCOSLDR_VolatileAlloc</code> : Used to allocate memory for immediate use (valid only until a new call to any memory function is made). Memory will be taken from top of free memory.<br />
The two first functions maintains the linked list of available blocks of memory.<br />
All function waits for the requested size in bytes (must be a multiple of 16), and returns a segment of memory aligned on 512 bytes boundaries to facilitate disk operations.</div>Kindmanhttp://wiki.amc-os.com/index.php?title=AMC-OS_Loader_Memory_management&diff=77AMC-OS Loader Memory management2020-04-13T15:12:42Z<p>Kindman: </p>
<hr />
<div>=Memory used during AMC-OS Loader execution=<br />
AMC-OS Loader uses only the first megabyte of memory :<br />
{|-<br />
|<code>00000-003FF</code><br />
|Real-mode interrupt table<br />
|-<br />
|<code>00400-00500</code><br />
|BIOS static data<br />
|-<br />
|<code>00501-005FF</code><br />
|Free (unused)<br />
|-<br />
|<code>00600-007FF</code><br />
|''Master boot record''<br />
|-<br />
|<code>00800-[__A]</code><br />
|Kernel static data (initialized by boot loader)<br />
|-<br />
|<code>[__A]-[__B]</code><br />
|AMC-OS Loader code<br />
|-<br />
|<code>[__B]-[__C]</code><br />
|AMC-OS Loader picture<br />
|-<br />
|<code>[__C]-077FF</code><br />
|''Free for allocation''<br />
|-<br />
|<code>077FF-07BFF</code><br />
|AMC-OS Loader stack<br />
|-<br />
|<code>07C00-07DFF</code><br />
|Boot loader code (VBR or MBR for floppy disk)<br />
|-<br />
|<code>07E00-07FFF</code><br />
|Free (unused)<br />
|-<br />
|<code>08000-9[_D]</code><br />
|''Free for allocation''<br />
|-<br />
|<code>9[_D]-09FFF</code><br />
|Extended BIOS data area (EBDA - optional)<br />
|}<br />
<br />
=Memory management=<br />
==Initialization==<br />
During memory initialization process (<code>AMCOSLDR_InitFirstMegabyte</code>), AMC-OS Loader :<br />
* looks for EBDA using interrupt 12H and value stored in 0040:000E to get highest pointer in memory [_D]<br />
* calculates the values of [__A] to get lowest pointer in memory<br />
* creates a linked list of available blocks of memory (AMCOSLDR_Malloc_Entry)<br />
* initializes two blocks of available memory (marked ''Free for allocation'' in previous table)<br />
<br />
==Allocation==<br />
Three functions are available to AMC-OS Loader for memory allocation :<br />
* <code>AMCOSLDR_DefinitiveAlloc</code> : Used to allocate memory that shall stay at this place at the end of the process (used by kernel afterwards). Memory will be taken from bottom of free memory.<br />
* <code>AMCOSLDR_TempAlloc</code> : Used to allocate memory that will be freed at the end of the process (eraseable by kernel afterwards). Memory will be taken from top of free memory.<br />
* <code>AMCOSLDR_VolatileAlloc</code> : Used to allocate memory for immediate use (valid only until a new call to any memory function is made). Memory will be taken from top of free memory.<br />
The two first functions maintains the linked list of available blocks of memory.</div>Kindmanhttp://wiki.amc-os.com/index.php?title=AMC-OS_Loader_Memory_management&diff=76AMC-OS Loader Memory management2020-04-13T15:11:58Z<p>Kindman: </p>
<hr />
<div>=Memory used during AMC-OS Loader execution=<br />
AMC-OS Loader uses only the first megabyte of memory :<br />
{|-<br />
|<code>00000-003FF</code><br />
|Real-mode interrupt table<br />
|-<br />
|<code>00400-00500</code><br />
|BIOS static data<br />
|-<br />
|<code>00501-005FF</code><br />
|Free (unused)<br />
|-<br />
|<code>00600-007FF</code><br />
|''Master boot record''<br />
|-<br />
|<code>00800-[__A]</code><br />
|Kernel static data (initialized by boot loader)<br />
|-<br />
|<code>[__A]-[__B]</code><br />
|AMC-OS Loader code<br />
|-<br />
|<code>[__B]-[__C]</code><br />
|AMC-OS Loader picture<br />
|-<br />
|<code>[__C]-077FF</code><br />
|''Free for allocation''<br />
|-<br />
|<code>077FF-07BFF</code><br />
|AMC-OS Loader stack<br />
|-<br />
|<code>07C00-07DFF</code><br />
|Boot loader code (VBR or MBR for floppy disk)<br />
|-<br />
|<code>07E00-07FFF</code><br />
|Free (unused)<br />
|-<br />
|<code>08000-9[_D]</code><br />
|''Free for allocation''<br />
|-<br />
|<code>9[_D]-09FFF</code><br />
|Extended BIOS data area (EBDA - optional)<br />
}<br />
=Memory management=<br />
==Initialization==<br />
During memory initialization process (<code>AMCOSLDR_InitFirstMegabyte</code>), AMC-OS Loader :<br />
* looks for EBDA using interrupt 12H and value stored in 0040:000E to get highest pointer in memory [_D]<br />
* calculates the values of [__A] to get lowest pointer in memory<br />
* creates a linked list of available blocks of memory (AMCOSLDR_Malloc_Entry)<br />
* initializes two blocks of available memory (marked ''Free for allocation'' in previous table)<br />
<br />
==Allocation==<br />
Three functions are available to AMC-OS Loader for memory allocation :<br />
* <code>AMCOSLDR_DefinitiveAlloc</code> : Used to allocate memory that shall stay at this place at the end of the process (used by kernel afterwards). Memory will be taken from bottom of free memory.<br />
* <code>AMCOSLDR_TempAlloc</code> : Used to allocate memory that will be freed at the end of the process (eraseable by kernel afterwards). Memory will be taken from top of free memory.<br />
* <code>AMCOSLDR_VolatileAlloc</code> : Used to allocate memory for immediate use (valid only until a new call to any memory function is made). Memory will be taken from top of free memory.<br />
The two first functions maintains the linked list of available blocks of memory.</div>Kindmanhttp://wiki.amc-os.com/index.php?title=AMC-OS_Loader_Memory_management&diff=75AMC-OS Loader Memory management2020-04-13T15:08:53Z<p>Kindman: Created page with "=Memory used during AMC-OS Loader execution= AMC-OS Loader uses only the first megabyte of memory : *<code>00000-003FF</code> : Real-mode interrupt table *<code>00400-00500</c..."</p>
<hr />
<div>=Memory used during AMC-OS Loader execution=<br />
AMC-OS Loader uses only the first megabyte of memory :<br />
*<code>00000-003FF</code> : Real-mode interrupt table<br />
*<code>00400-00500</code> : BIOS static data<br />
*<code>00501-005FF</code> : Free (unused)<br />
*<code>00600-007FF</code> : ''Master boot record''<br />
*<code>00800-[__A]</code> : Kernel static data (initialized by boot loader)<br />
*<code>[__A]-[__B]</code> : AMC-OS Loader code<br />
*<code>[__B]-[__C]</code> : AMC-OS Loader picture<br />
*<code>[__C]-077FF</code> : ''Free for allocation''<br />
*<code>077FF-07BFF</code> : AMC-OS Loader stack<br />
*<code>07C00-07DFF</code> : Boot loader code (VBR or MBR for floppy disk)<br />
*<code>07E00-07FFF</code> : Free (unused)<br />
*<code>08000-9[_D]</code> : ''Free for allocation''<br />
*<code>9[_D]-09FFF</code> : Extended BIOS data area (EBDA - optional)<br />
<br />
=Memory management=<br />
==Initialization==<br />
During memory initialization process (<code>AMCOSLDR_InitFirstMegabyte</code>), AMC-OS Loader :<br />
* looks for EBDA using interrupt 12H and value stored in 0040:000E to get highest pointer in memory [_D]<br />
* calculates the values of [__A] to get lowest pointer in memory<br />
* creates a linked list of available blocks of memory (AMCOSLDR_Malloc_Entry)<br />
* initializes two blocks of available memory (marked ''Free for allocation'' in previous table)<br />
<br />
==Allocation==<br />
Three functions are available to AMC-OS Loader for memory allocation :<br />
* <code>AMCOSLDR_DefinitiveAlloc</code> : Used to allocate memory that shall stay at this place at the end of the process (used by kernel afterwards). Memory will be taken from bottom of free memory.<br />
* <code>AMCOSLDR_TempAlloc</code> : Used to allocate memory that will be freed at the end of the process (eraseable by kernel afterwards). Memory will be taken from top of free memory.<br />
* <code>AMCOSLDR_VolatileAlloc</code> : Used to allocate memory for immediate use (valid only until a new call to any memory function is made). Memory will be taken from top of free memory.<br />
The two first functions maintains the linked list of available blocks of memory.</div>Kindmanhttp://wiki.amc-os.com/index.php?title=AMC-OS_Loader&diff=74AMC-OS Loader2020-04-13T14:46:32Z<p>Kindman: </p>
<hr />
<div>==Introduction==<br />
<br />
AMC-OS Loader is a module part of the [[Boot process|boot process]]. Its task is to locate the kernel in the booting volume, load it in memory and prepare all the necessary structures to start it.<br />
<br />
AMC-OS Loader gives us much more flexibility in [[Boot process|boot process]], as we no longer have the limitation of 512 bytes of code. However, the CPU is still running in real mode, implying limitations in the size of structures and files we have to manipulate.<br />
<br />
==Process==<br />
[[image:Amcos_loader.png|right|thumb|250px|AMC-OS Loader splash screen]]<br />
AMC-OS Loader follow this procedure :<br />
* Wait for options (typically F1 for debugging purposes if compiled with DEBUG support)<br />
* System check : Check that we have a 386+ running in real-mode<br />
* Check for EBDA and initialize first MB of memory to allow memory allocation : [[AMC-OS Loader Memory management]]<br />
* Ask BIOS information on the available RAM in the system.<br />
* Precisely [[Identifying CPU|identify the CPU]] using either the CPUID instruction or a CPU reset, and calculates its running frequency<br />
* Check if we start from a MBR (removeable media) or a VBR and locate volume to boot<br />
* Identify the volume type (FAT12, FAT16...) and initialize according filesystem driver.<br />
* Locate and load the required kernel files<br />
* Identify the video graphics card, check VESA support to get best text resolution during kernel initialization<br />
* Prepare the CPU for protected mode (GDT and system descriptors)<br />
* Do a first switch to protected mode to decode kernel AMCX file and relocate it in memory<br />
* Do a second switch to protected mode to start kernel<br />
<br />
==Files==<br />
AMC-OS Loader is composed of two files :<br />
* <tt>AMCOSLDR.SYS</tt> contains raw code of AMC-OS Loader (no header nor relocation).<br />
* <tt>AMCOSLDR.IMG</tt> is a picture of AMC-OS Logo displayed during AMC-OS Loader execution.<br />
<br />
Both files are loaded by the [[Boot process#The Boot Loader|boot sector]].<br />
<br />
==16-bit code and V86==<br />
AMC-OS Loader stays in memory to allow 16-bit code to be executed from Kernel in V86 mode, typically to call INT 10H (video)</div>Kindmanhttp://wiki.amc-os.com/index.php?title=AMC-OS_Loader&diff=73AMC-OS Loader2017-05-16T10:52:52Z<p>Kindman: /* Process */</p>
<hr />
<div>==Introduction==<br />
<br />
AMC-OS Loader is a module part of the [[Boot process|boot process]]. Its task is to locate the kernel in the booting volume, load it in memory and prepare all the necessary structures to start it.<br />
<br />
AMC-OS Loader gives us much more flexibility in [[Boot process|boot process]], as we no longer have the limitation of 512 bytes of code. However, the CPU is still running in real mode, implying limitations in the size of structures and files we have to manipulate.<br />
<br />
==Process==<br />
[[image:Amcos_loader.png|right|thumb|250px|AMC-OS Loader splash screen]]<br />
AMC-OS Loader follow this procedure :<br />
* System check : Check that we have a 386+ running in real-mode<br />
* Ask BIOS information on the available RAM in the system and initialize low memory (<640KB) for allocation.<br />
* Precisely [[Identifying CPU|identify the CPU]] using either the CPUID instruction or a CPU reset, and calculates its running frequency<br />
* Check if we start from a MBR (removeable media) or a VBR and locate volume to boot<br />
* Identify the volume type (FAT12, FAT16...) and initialize according filesystem driver.<br />
* Locate and load the required kernel files<br />
* Identify the video graphics card, check VESA support to get best text resolution during kernel initialization<br />
* Prepare the CPU for protected mode (GDT and system descriptors)<br />
* Do a first switch to protected mode to decode kernel AMCX file and relocate it in memory<br />
* Do a second switch to protected mode to start kernel<br />
<br />
==Files==<br />
AMC-OS Loader is composed of two files :<br />
* <tt>AMCOSLDR.SYS</tt> contains raw code of AMC-OS Loader (no header nor relocation).<br />
* <tt>AMCOSLDR.IMG</tt> is a picture of AMC-OS Logo displayed during AMC-OS Loader execution.<br />
<br />
Both files are loaded by the [[Boot process#The Boot Loader|boot sector]].</div>Kindmanhttp://wiki.amc-os.com/index.php?title=AMC-OS_Loader&diff=72AMC-OS Loader2017-05-16T10:49:43Z<p>Kindman: /* Introduction */</p>
<hr />
<div>==Introduction==<br />
<br />
AMC-OS Loader is a module part of the [[Boot process|boot process]]. Its task is to locate the kernel in the booting volume, load it in memory and prepare all the necessary structures to start it.<br />
<br />
AMC-OS Loader gives us much more flexibility in [[Boot process|boot process]], as we no longer have the limitation of 512 bytes of code. However, the CPU is still running in real mode, implying limitations in the size of structures and files we have to manipulate.<br />
<br />
==Process==<br />
[[image:Amcos_loader.png|right|thumb|250px|AMC-OS Loader splash screen]]<br />
AMC-OS Loader follow this procedure :<br />
* System check : Check that we have a 386+ running in real-mode<br />
* Load and compare the disk FATs, converts them to FAT16 for simpler management (for FAT12 floppy disks)<br />
* Locate the <tt>MODULES</tt> directory containing all kernel files required for boot<br />
* Load all kernel files in memory using the contents of the <tt>[[AMCOS.MOD]]</tt> file<br />
* Precisely [[Identifying CPU|identify the CPU]] using either the CPUID instruction or a CPU reset, and calculates its running frequency<br />
* Identify the video graphics card, check VESA support to get best text resolution during kernel initialization<br />
* Prepare the CPU for protected mode (GDT and system descriptors)<br />
* Do a first switch to protected mode to decode kernel AMCX file and relocate it in memory<br />
* Do a second switch to protected mode to start kernel<br />
<br />
==Files==<br />
AMC-OS Loader is composed of two files :<br />
* <tt>AMCOSLDR.SYS</tt> contains raw code of AMC-OS Loader (no header nor relocation).<br />
* <tt>AMCOSLDR.IMG</tt> is a picture of AMC-OS Logo displayed during AMC-OS Loader execution.<br />
<br />
Both files are loaded by the [[Boot process#The Boot Loader|boot sector]].</div>Kindmanhttp://wiki.amc-os.com/index.php?title=Boot_process&diff=71Boot process2017-05-16T10:46:16Z<p>Kindman: /* The Boot Loader */</p>
<hr />
<div>==Introduction==<br />
<br />
AMC-OS booting process is done in three different phases :<br />
* [[Boot process#The Boot Loader|The boot loader]] ''(also named volume boot record (VBR) or master boot record (MBR) for removeable media)''<br />
* [[AMC-OS Loader]] - Check system, CPU, memory, loads and relocates Kernel in memory<br />
* '''Kernel initialization''' - Initializes all structures to start the AMC-OS kernel<br />
<br />
At power up, and after BIOS initialization, for historical/compatibility reasons, the processor runs in real adressing mode. In this mode, the CPU runs a 16-byte memory adressing scheme, meaning that we can only address 16 segments of 64KB of memory (ie 1MB), divided in "user" memory (640KB - the so-called "conventional memory" in MS-DOS) and Video RAM+System ROMS (384KB).<br />
<br />
We have to switch the processor to 32-bit protected mode to run a 32-byte memory adressing scheme and adress 4GB of physical memory. It is even possible, starting with the Pentium Pro, to run a 36-byte memory addressing, called PAE (Physical Address Extension), allowing the adressing of 64GB of memory.<br />
<br />
Switching to protected mode requires some preparation and resources, and most BIOS functions are no longer available (ie. disk read, changing video mode...), meaning that we must have loaded all kernel required files in memory before switching.<br />
<br />
==The Boot Loader==<br />
The boot loader is the first sector (512 bytes) of the source media (typically the floppy disk). The BIOS automatically loads the first sector of the specified media during system boot process, at physical memory address <tt>00007C00</tt>, checks that the last word value is <tt>55AA</tt>, and if so, jump execution to first byte.<br />
<br />
AMC-OS 1.44M Boot Floppy disks are in standard FAT12 format and contains the adequate header. There lasts only 451 bytes to :<br />
* Load the FAT and Root directory (\) listing in memory<br />
* Locate <tt>AMCOSLDR.IMG</tt> and <tt>AMCOSLDR.SYS</tt> files in the root directory<br />
* Load the files in memory<br />
* Switch execution to AMC-OS Loader<br />
<br />
The boot loader uses BIOS support through <tt>INT 13H</tt> for I/O functions.<br />
In case of error during execution, the boot loader will display :<br />
* <tt>FIL?</tt> or <tt>File not found</tt> if one of the required files hasn't been found in the root directory<br />
* <tt>DSK?</tt> or <tt>Read error</tt> if a read error occured (probably defective disk)<br />
<br />
==AMC-OS Loader==<br />
''See complete article : '' [[AMC-OS Loader]]</div>Kindmanhttp://wiki.amc-os.com/index.php?title=Boot_process&diff=70Boot process2017-05-16T10:45:14Z<p>Kindman: /* Introduction */</p>
<hr />
<div>==Introduction==<br />
<br />
AMC-OS booting process is done in three different phases :<br />
* [[Boot process#The Boot Loader|The boot loader]] ''(also named volume boot record (VBR) or master boot record (MBR) for removeable media)''<br />
* [[AMC-OS Loader]] - Check system, CPU, memory, loads and relocates Kernel in memory<br />
* '''Kernel initialization''' - Initializes all structures to start the AMC-OS kernel<br />
<br />
At power up, and after BIOS initialization, for historical/compatibility reasons, the processor runs in real adressing mode. In this mode, the CPU runs a 16-byte memory adressing scheme, meaning that we can only address 16 segments of 64KB of memory (ie 1MB), divided in "user" memory (640KB - the so-called "conventional memory" in MS-DOS) and Video RAM+System ROMS (384KB).<br />
<br />
We have to switch the processor to 32-bit protected mode to run a 32-byte memory adressing scheme and adress 4GB of physical memory. It is even possible, starting with the Pentium Pro, to run a 36-byte memory addressing, called PAE (Physical Address Extension), allowing the adressing of 64GB of memory.<br />
<br />
Switching to protected mode requires some preparation and resources, and most BIOS functions are no longer available (ie. disk read, changing video mode...), meaning that we must have loaded all kernel required files in memory before switching.<br />
<br />
==The Boot Loader==<br />
The boot loader is the first sector (512 bytes) of the source media (typically the floppy disk). The BIOS automatically loads the first sector of the specified media during system boot process, at physical memory address <tt>00007C00</tt>, checks that the last word value is <tt>55AA</tt>, and if so, jump execution to first byte.<br />
<br />
AMC-OS 1.44M Boot Floppy disks are in standard FAT12 format and contains the adequate header. There lasts only 451 bytes to :<br />
* Load the FAT and Root directory (\) listing in memory<br />
* Locate <tt>AMCOSLDR.IMG</tt> and <tt>AMCOSLDR.SYS</tt> files in the root directory<br />
* Load the files to fixed memory addresses<br />
* Switch execution to AMC-OS Loader<br />
<br />
The boot loader uses BIOS support through <tt>INT 13H</tt> for I/O functions.<br />
In case of error during execution, the boot loader will display :<br />
* <tt>FIL?</tt> if one of the required files hasn't been found in the root directory<br />
* <tt>DSK?</tt> if a read error occured (probably defective disk)<br />
<br />
==AMC-OS Loader==<br />
''See complete article : '' [[AMC-OS Loader]]</div>Kindmanhttp://wiki.amc-os.com/index.php?title=Memory_and_paging&diff=69Memory and paging2015-07-19T22:01:47Z<p>Kindman: </p>
<hr />
<div><br />
== Memory model ==<br />
<br />
=== Physical memory ===<br />
<br />
Physical memory is divided in several segments that can be used by the system.<br />
During initialization phase, the system scan the linear address space for the available segments. In a standard PC, there are typically two segments : the first megabyte of memory (generally only the first 640Kbytes as BIOS, ROMs and video memory are mapped in the last 384Kbytes) and the memory above 1MB. In some cases, there also can be a hole in the 15-16M adressing space, or memory reserved for PCI addressing space. During the scan, the system counts the number of available blocks in each segment.<br />
<br />
AMC-OS split the physical memory in two areas :<br />
* low memory reserved for kernel usage (''will also be referred as '''kernel memory''')'';<br />
* high memory for processes ''(will also be referred as '''user memory''')''. <br />
These two areas are divided in contiguous blocks of 256Kbytes by default, themselves being divided in 4Kbytes pages. To reduce the amount of memory used by the system, the blocks are activated on demand, and only then divided in pages.<br />
<br />
=== Virtual memory ===<br />
<br />
<br />
<br />
== Physical memory management ==<br />
<br />
=== Memory areas ===<br />
<br />
After scanning the linear address space for available physical memory, AMC-OS split the physical memory in two areas :<br />
* The '''low memory area''' must be at least 4Mbytes large, and its size is proportional to the total amount of physical memory available. This area is also referred as ''kernel memory'' as the physical memory is available from all page directories at kernel privilege.<br />
* The '''high memory area''' contains all the remaining memory and is used for user memory.<br />
<br />
Each area is specified in a <tt>MEMORY_AREA</tt> structure. It contains :<br />
* the number and pointers to the used blocks they contain;<br />
* the number and pointers to the free blocks they contain;<br />
* the number and pointers to the free pages.<br />
<br />
User memory can be taken from low memory if high memory is exhausted.<br />
<br />
=== Free blocks list ===<br />
<br />
By default, each memory area is divided in blocks of 256 Kbytes. A new block is ''activated'' and divided in free pages, if there are no more free pages available in the area. Free blocks are stored in the ''free blocks list'', a linked list of the '''InactiveMemory''' structure. It contains :<br />
* the pointer to the free block;<br />
* the number of contiguous free blocks;<br />
* the pointer to the next structure.<br />
During initialization phase, we pre-allocate the maximum of free blocks structures that can be necessary, ie half the number of blocks. This list of free blocks structures is also a linked list to accelerate allocating and freeing processes.<br />
<br />
The pointer to the free blocks list is stored in <tt>MEMORY_AREA.ptrFreeBlocks</tt>, and count in <tt>MEMORY_AREA.nbFreeBlocks</tt>.<br />
<br />
The pointer to the free blocks structures list is stored in <tt>MEMORY_ptrInactiveFreeBlocksStruct</tt>, and count in <tt>MEMORY_nbInactiveFreeBlocksStruct</tt>.<br />
<br />
=== Number of free pages per block ===<br />
<br />
A free pages per block table is created to be able to put back in free blocks list a block that has all its pages free.<br />
It is a simple table indexed by the block number, containing for each entry an unsigned byte with the number of free pages. Obviously, there can't be more than 256 pages per block (64 by default).</div>Kindmanhttp://wiki.amc-os.com/index.php?title=Memory_and_paging&diff=68Memory and paging2014-08-24T13:08:58Z<p>Kindman: </p>
<hr />
<div><br />
== Memory model ==<br />
<br />
=== Physical memory ===<br />
<br />
Physical memory is divided in several segments that can be used by the system.<br />
During initialization phase, the system checks the different segments. There are typically two segments, the first megabyte of memory and the upper memory. In some cases, there also can be a hole in the 15-16M adressing space, or for PCI address space. In the same time, the system count the number of blocks (256K by default) in each segment.<br />
<br />
The physical memory is split by the system in two areas, low memory reserved for kernel usage (that will also be referred as "kernel memory") and high memory for processes. These two areas are divided in contiguous blocks, themselves being divided in pages. To reduce the amount of memory used by the system, the blocks are activated on demand, and then divided in pages.<br />
<br />
=== Virtual memory ===<br />
<br />
<br />
<br />
== Physical memory management ==<br />
<br />
=== Memory areas ===<br />
<br />
The low memory area must be at least 4MB large, and its size is proportional to the total amount of physical memory available.<br />
Each area is characterized in a <tt>MEMORY_AREA</tt> structures with the number and pointers to the used and free blocks they contain, and to the free pages.<br />
<br />
User memory is always taken first from high memory, then low memory if empty. Kernel memory is always taken only in low memory.<br />
<br />
=== Free blocks list ===<br />
<br />
The free blocks list is a linked list of the '''InactiveMemory''' structure. It contains the pointer to the free block, the number of contiguous free blocks and the pointer to the next structure. During initialization phase, we pre-allocate the maximum of free blocks structures that can be necessary, ie half the number of blocks. This list of free blocks structures is also a linked list to accelerate allocating and freeing processes.<br />
<br />
The pointer to the free blocks list is stored in <tt>MEMORY_AREA.ptrFreeBlocks</tt>, and count in <tt>MEMORY_AREA.nbFreeBlocks</tt>.<br />
<br />
The pointer to the free blocks structures list is stored in <tt>MEMORY_ptrInactiveFreeBlocksStruct, and count in <tt>MEMORY_nbInactiveFreeBlocksStruct</tt>.<br />
<br />
=== Number of free pages per block ===<br />
<br />
A free pages per block table is created to be able to put back in free blocks list a block that has all its pages free.<br />
It is a simple table indexed by the block number, containing for each entry an unsigned byte with the number of free pages. Obviously, there can't be more than 256 pages per block (64 by default).</div>Kindmanhttp://wiki.amc-os.com/index.php?title=Memory_and_paging&diff=67Memory and paging2014-08-24T13:08:04Z<p>Kindman: </p>
<hr />
<div><br />
== Memory model ==<br />
<br />
=== Physical memory ===<br />
<br />
Physical memory is divided in several segments that can be used by the system.<br />
During initialization phase, the system checks the different segments. There are typically two segments, the first megabyte of memory and the upper memory. In some cases, there also can be a hole in the 15-16M adressing space, or for PCI address space. In the same time, the system count the number of blocks (256K by default) in each segment.<br />
<br />
The physical memory is split by the system in two areas, low memory reserved for kernel usage (that will also be referred as "kernel memory") and high memory for processes. These two areas are divided in contiguous blocks, themselves being divided in pages. To reduce the amount of memory used by the system, the blocks are activated on demand, and then divided in pages.<br />
<br />
=== Virtual memory ===<br />
<br />
<br />
<br />
== Physical memory management ==<br />
<br />
=== Memory areas ===<br />
<br />
The low memory area must be at least 4MB large, and its size is proportional to the total amount of physical memory available.<br />
Each area is characterized in a <tt>MEMORY_AREA</tt> structures with the number and pointers to the used and free blocks they contain, and to the free pages.<br />
<br />
User memory is always taken first from high memory, then low memory if empty. Kernel memory is always taken only in low memory.<br />
<br />
=== Free blocks list ===<br />
<br />
The free blocks list is a linked list of the '''InactiveMemory''' structure. It contains the pointer to the free block, the number of contiguous free blocks and the pointer to the next structure. During initialization phase, we pre-allocate the maximum of free blocks structures that can be necessary, ie half the number of blocks. This list of free blocks structures is also a linked list to accelerate allocating and freeing processes.<br />
<br />
The pointer to the free blocks list is stored in <tt>MEMORY_AREA.ptrFreeBlocks</tt>, and count in <tt>MEMORY_AREA.nbFreeBlocks</tt>.<br />
<br />
The pointer to the free blocks structures list is stored in <tt>MEMORY_ptrInactiveFreeBlocksStruct, and count in <tt>MEMORY_nbInactiveFreeBlocksStruct</tt>.<br />
<br />
=== Number of free pages per block ===<br />
<br />
A free pages per block table is created to be able to put back in free blocks list a block that has all its pages free.<br />
It is a simple table indexed by the number of block, containing for each entry an unsigned byte with the number of free pages. Obviously, there can't be more than 256 pages per block (64 by default).</div>Kindmanhttp://wiki.amc-os.com/index.php?title=Memory_and_paging&diff=66Memory and paging2014-08-24T13:05:18Z<p>Kindman: Created page with " == Memory model == === Physical memory === Physical memory is divided in several segments that can be used by the system. During initialization phase, the system checks the..."</p>
<hr />
<div><br />
== Memory model ==<br />
<br />
=== Physical memory ===<br />
<br />
Physical memory is divided in several segments that can be used by the system.<br />
During initialization phase, the system checks the different segments. There are typically two segments, the first megabyte of memory and the upper memory. In some cases, there also can be a hole in the 15-16M adressing space, or for PCI address space. In the same time, the system count the number of blocks (256K by default) in each segment.<br />
<br />
The physical memory is split by the system in two areas, low memory reserved for kernel usage (that will also be referred as "kernel memory") and high memory for processes. These two areas are divided in contiguous blocks, themselves being divided in pages. To reduce the amount of memory used by the system, the blocks are activated on demand, and then divided in pages.<br />
<br />
=== Virtual memory ===<br />
<br />
<br />
<br />
== Physical memory management ==<br />
<br />
=== Memory areas ===<br />
<br />
The low memory area must be at least 4MB large, and its size is proportional to the total amount of physical memory available.<br />
Each area is characterized in a MEMORY_AREA structures with the number and pointers to the used and free blocks they contain, and to the free pages.<br />
<br />
User memory is always taken first from high memory, then low memory if empty. Kernel memory is always taken only in low memory.<br />
<br />
=== Free blocks list ===<br />
<br />
The free blocks list is a linked list of the '''InactiveMemory''' structure. It contains the pointer to the free block, the number of contiguous free blocks and the pointer to the next structure. During initialization phase, we pre-allocate the maximum of free blocks structures that can be necessary, ie half the number of blocks. This list of free blocks structures is also a linked list to accelerate allocating and freeing processes.<br />
<br />
The pointer to the free blocks list is stored in MEMORY_AREA.ptrFreeBlocks, and count in MEMORY_AREA.nbFreeBlocks.<br />
The pointer to the free blocks structures list is stored in MEMORY_ptrInactiveFreeBlocksStruct, and count in MEMORY_nbInactiveFreeBlocksStruct.<br />
<br />
=== Number of free pages per block ===<br />
<br />
A free pages per block table is created to be able to put back in free blocks list a block that has all its pages free.<br />
It is a simple table indexed by the number of block, containing for each entry an unsigned byte with the number of free pages. Obviously, there can't be more than 256 pages per block (64 by default).</div>Kindmanhttp://wiki.amc-os.com/index.php?title=Interrupts&diff=65Interrupts2013-07-18T14:43:04Z<p>Kindman: minor checks</p>
<hr />
<div>==Introduction==<br />
<br />
===Processor===<br />
====General considerations====<br />
<br />
The processor can interrupt the execution of the current process on 3 different event types :<br />
* Exceptions/Faults : the running process made a fault, like the typical "General Protection Fault" when the process read or wrote memory in a forbidden place.<br />
* Software interrupts : The process called an interrupt with the INT XX instruction.<br />
* Hardware interrupts : Associated hardware raised the INT# line of the processor to inform it of any kind of event that just happened, like for a example "a key has been pressed".<br />
<br />
The x86 family support 256 interrupts, and the first 32 are reserved for the exceptions and traps generated by the processor itself. All the others are available to software and external hardware. <br />
<br />
====Interrupt Descriptor Table (IDT)====<br />
The OS maintains an ''interrupt descriptor table'' used by the processor to know what to do when a specific interrupt is triggered. In real mode, it is just a list of FAR jump addresses located at physical memory address 0. In protected mode, it is a table of descriptors (interrupt gate, task gate...). <br />
<br />
Once prepared, the interrupt descriptor table is set up using the LIDT instruction.<br />
<br />
===Hardware interrupts (IRQ)===<br />
<br />
Whenever the hardware wants to inform the system that something happened, like a new disc has been inserted or the user moved the mouse for example, it can deal with it in two ways :<br />
* Update its internal status and wait for the operating system to check for it (this method is called ''polling'').<br />
* Request the interruption (IRQ) of the current process execution to immediately inform the operating system of a pending event.<br />
<br />
Both methods have their own interest, but the thing to keep in mind is that interrupts are used to treat the event as quickly as possible. Interrupts are more resource consuming due to task switching and they reduce the control on how CPU time division between processes, but if the OS doesn't check as quickly as necessary the hardware status, it can possibly lose data (like for a high rate network card, the buffer can be full and overrun if the OS doesn't read it before next packets arrive).<br />
<br />
====The Programmable Interrupt Controller====<br />
<br />
As on most microcomputers, the x86 CPU have two external interrupt lines : a software maskable (SMI) and a non-maskable interrupt line (NMI). The SMI is used by standard hardware to trigger an interrupt, and the NMI is used during critical condition (memory or I/O parity error) or to force the OS to an escape routine.<br />
<br />
To handle different interrupts, an programmable interrupt controller (PIC) is added. The PIC can handle multiple interrupt lines, priority between them, individual masking and so on. When an interrupt comes in, the INT# line is triggered and the interrupt number is sent to the CPU through data bus. <br />
<br />
On the x86 family, the [[#Programming the i8259 PIC|i8259 PIC]] was first used in the XT. It supported 8 differents IRQ. On the AT, an other i8259 was cascaded to the first one, leading up to 15 differents IRQs (16 minor the one used for cascading). It is only since some Pentium processors that it was replaced by an advanced PIC (APIC) supporting, amongst other things, 23 differents IRQ.<br />
<br />
==Programming the i8259 PIC==<br />
<br />
===Original specifications===<br />
[http://www.amc-os.com/developers/specifications/intel_8259a.pdf Intel 8259A datasheet]</div>Kindmanhttp://wiki.amc-os.com/index.php?title=Interrupts&diff=64Interrupts2012-08-30T13:00:29Z<p>Kindman: added i8259a spec</p>
<hr />
<div>==Introduction==<br />
<br />
===Processor===<br />
====General considerations====<br />
<br />
The processor can interrupt the execution of the current process due to 3 different types of interruptions :<br />
* Exceptions/Faults : the running process made a fault, like for example the typical "General Protection Fault" if the process read or wrote memory in a wrong place.<br />
* Software interrupts : The process called an interrupt with the INT XX instruction.<br />
* Hardware interrupts : Associated hardware raised the INT# line of the processor to inform it of any kind of event that just happened, like for a example "a key has been pressed".<br />
<br />
The x86 family support 256 interrupts, and the first 32 are reserved for the exceptions and traps generated by the processor itself. All the others are available to software and external hardware. <br />
<br />
====Interrupt Descriptor Table (IDT)====<br />
The OS maintains an ''interrupt descriptor table'' used by the processor to know what to do when a specific interrupt is triggered. In real mode, it is just a list of FAR jump addresses located at physical memory address 0. In protected mode, it is a table of descriptors (interrupt gate, task gate...). <br />
<br />
Once prepared, the interrupt descriptor table is set up using the LIDT instruction.<br />
<br />
===Hardware interrupts (IRQ)===<br />
<br />
Whenever the hardware wants to inform the system that something happened, like a new disc has been inserted or the user moved the mouse for example, it can deal with it in two different ways :<br />
* Update its internal status and wait for the operating system to check for it (this method is called ''polling'').<br />
* Request the interruption (IRQ) of the current process execution to immediately inform the operating system of an event to deal with.<br />
<br />
Both methods have their own interest, but the thing to keep in mind is that interrupts are used to treat the event as quickly as possible. Interrupts are more resource consuming due to task switching, and reduce control on how CPU time is divided between each process, but if the OS doesn't check as quickly as necessary the hardware status, it can possibly lose date (like for a high rate network card, the buffer can be full and overrun if the OS doesn't read it before next packets arrive).<br />
<br />
====The Programmable Interrupt Controller====<br />
<br />
As on most microcomputers, the x86 CPU have two external interrupt lines : a software maskable (SMI) and a non-maskable interrupt line (NMI). The SMI is used by standard hardware to trigger an interrupt, and the NMI is used during critical condition (memory or I/O parity error) or to force the OS to an escape routine.<br />
<br />
To handle different interrupts, an programmable interrupt controller (PIC) is added. The PIC can handle multiple interrupt lines, priority between them, individual masking and so on. When an interrupt comes in, the INT# line is triggered and the interrupt number is sent to the CPU through data bus. <br />
<br />
On the x86 family, the [[#Programming the i8259 PIC|i8259 PIC]] was first used in the XT. It supported 8 differents IRQ. On the AT, an other i8259 was cascaded to the first one, leading up to 15 differents IRQs (16 minor the one used for cascading). It is only since some Pentium processors that it was replaced by an advanced PIC (APIC) supporting, amongst other things, 23 differents IRQ.<br />
<br />
==Programming the i8259 PIC==<br />
<br />
===Original specifications===<br />
[http://www.amc-os.com/developers/specifications/intel_8259a.pdf Intel 8259A datasheet]</div>Kindmanhttp://wiki.amc-os.com/index.php?title=Floppy_disk_controller&diff=63Floppy disk controller2012-08-30T12:53:01Z<p>Kindman: </p>
<hr />
<div>==Introduction==<br />
<br />
The floppy disk controller is used to control up to 4 floppy disk drives.<br />
<br />
In the PC computer, it was originally based on a Nec uPD765 chip. On the PC/AT, a register was added to inform the OS that the media changed, and several other registers were added in the PS/2 and Model30 computers. Enhanced controllers were then implemented, with new functions and support of perpendicular mode, generally based on the Intel 82077AA chip.<br />
<br />
==Original specifications==<br />
<br />
* [http://www.amc-os.com/developers/specifications/intel_82072.pdf Intel 82072 datasheet]<br />
* [http://www.amc-os.com/developers/specifications/nec_uPD765B.pdf Nec uPD765B datasheet]<br />
* [http://www.amc-os.com/developers/specifications/intel_82077aa.pdf Intel 82077AA datasheet]<br />
* [http://www.amc-os.com/developers/specifications/intel_82078.pdf Intel 82078 datasheet]</div>Kindmanhttp://wiki.amc-os.com/index.php?title=Floppy_disk_controller&diff=62Floppy disk controller2012-08-30T12:38:40Z<p>Kindman: </p>
<hr />
<div>==Introduction==<br />
<br />
The floppy disk controller is used to control up to 4 floppy disk drives.<br />
<br />
In the PC computer, it was originally based on a Nec uPD765 chip. On the PC/AT, a register was added to inform the OS that the media changed, and several other registers were added in the PS/2 and Model30 computers. Enhanced controllers were then implemented, with new functions and support of perpendicular mode, generally based on the Intel 82077AA chip.<br />
<br />
==Original specifications==<br />
<br />
* [http://www.amc-os.com/developers/specifications/nec_uPD765B.pdf Nec uPD765B datasheet]<br />
* [http://www.amc-os.com/developers/specifications/intel_82072.pdf Intel 82072 datasheet]<br />
* [http://www.amc-os.com/developers/specifications/intel_82077aa.pdf Intel 82077AA datasheet]</div>Kindmanhttp://wiki.amc-os.com/index.php?title=Floppy_disk_controller&diff=61Floppy disk controller2012-08-30T12:32:06Z<p>Kindman: page creation</p>
<hr />
<div>==Introduction==<br />
<br />
The floppy disk controller is used to control up to 4 floppy disk drives.<br />
<br />
In the PC computer, it was originally based on a Nec uPD765 chip. On the PC/AT, a register was added to inform the OS that the media changed, and several other registers were added in the PS/2 and Model30 computers. Enhanced controllers were then implemented, with new functions and support of perpendicular mode, generally based on the Intel 82077AA chip.<br />
<br />
==Original specifications==</div>Kindmanhttp://wiki.amc-os.com/index.php?title=Main_Page&diff=60Main Page2012-08-30T12:27:52Z<p>Kindman: </p>
<hr />
<div>[[File:Amc-os_ant_final.png|top|right|frame|AMC-OS Logo]]<br />
<br />
==Welcome to AMC-OS Developers Website==<br />
<br />
The AMC-OS Developers Website provides resources and information for people who :<br />
* want to support AMC-OS development<br />
* want to understand better how computers and OS work<br />
* look for documentation and tools to build their own system<br />
The website is divided into several sections depending on the information you are looking for.<br />
<br />
To get general information on AMC-OS, please visit the [http://www.amc-os.com/ main website].<br />
<br />
All AMC-OS code and documentation is released under the [[AMC-OS Developers:General disclaimer|AMC-OS License]]<br />
<br />
{| class="wikitable" cellpadding="5" width="60%"<br />
|+ AMC-OS Developers Website sections<br />
! scope="col" | OS Design<br />
! scope="col" | Hardware<br />
! scope="col" | Running AMC-OS<br />
|- style="vertical-align:top;"<br />
|<br />
* [[Processor management]]<br />
* [[Boot process]]<br />
* [[AMCX file format]]<br />
* [[Memory and paging]]<br />
* [[Processes and threads]]<br />
* [[Device drivers]]<br />
|<br />
* CPU<br />
** [[Intel x86 Architecture]]<br />
** [[Identifying CPU]]<br />
* [[Interrupts]] (PIC, APIC)<br />
* Devices identification<br />
** [[BIOS]]<br />
** [[Plug & Play]]<br />
** [[PCI]]<br />
* I/O<br />
** [[Floppy disk controller]]<br />
** [[IDE (ATA/ATAPI) controller]]<br />
|<br />
* [[Compiling and Linking]]<br />
* [[Installing and running]]<br />
* [[Debugging]]<br />
|-<br />
! scope="col" | Building software<br />
! scope="col" | Tools and resources<br />
! scope="col" |<br />
|- style="vertical-align:top;"<br />
|<br />
* [[AMC-OS Kernel API]]<br />
* [[AMC-OS C Library]]<br />
* [[Compiling and Linking]]<br />
|<br />
|<br />
|}</div>Kindman