Segmentation is a memory management scheme used in x86 architecture to divide the memory into different segments or memory chunks, each with a specific purpose and set of permissions. This method allows for efficient organization, protection, and use of memory. In x86 architecture, segmentation plays a critical role in both real mode and protected mode operations, providing a way to address more memory than what can be accessed directly with a single register.

Historical Context

Segmentation originated with the Intel 8086 processor, which featured a 20-bit address bus, allowing it to access up to 1 MB of memory. However, since the registers were only 16 bits wide, a direct addressing scheme couldn't fully utilize the available memory. To overcome this limitation, Intel introduced segmentation.

1 Segmentation in Real Mode

Segmentation in real mode is a technique to expand the addressable memory space beyond the 16-bit limit of the CPU's registers. By combining a 16-bit segment value with a 16-bit offset, real mode can address up to 1 MB of memory.

Segmentation Layout

In real mode, memory is logically divided into segments, each starting at an address specified by the segment register. Here is how different segment registers are typically used:

• Code Segment (CS): Holds the base address of the code being executed.
• Data Segment (DS): Holds the base address of data variables.
• Stack Segment (SS): Holds the base address of the stack used for function calls, local variables, and interrupt handling.
• Extra Segment (ES): Holds an additional data segment address.

These segments overlap in the physical memory, meaning the same physical address can be addressed in multiple ways depending on the segment and offset used.

Example of Segment Overlap

If CS is set to 0x1000 and DS is set to 0x1001, both CS:0x0010 and DS:0x0000 will point to the same physical address:

Physical Address from CS:0x0010=(0x1000×16)+0x0010

= 0x10000+0x0010

= 0x10010   

Physical Address from DS:0x0000=(0x1001×16)+0x0000=0x10010+0x0000=0x10010\text{Physical Address from DS:0x0000} = (0x1001 \times 16) + 0x0000 = 0x10010 + 0x0000 = 0x10010Physical Address from DS:0x0000= (0x1001×16)+0x0000

= 0x10010+0x0000

= 0x10010

Both calculations result in the same physical address 0x10010.

Importance of Segmentation in Real Mode

• Addressing Beyond 64 KB: By using segmentation, the CPU can address up to 1 MB of memory despite the 16-bit limit on registers.
• Program Structure: Segmentation allows separating code, data, and stack, which helps in organizing and managing programs.
• Compatibility: Segmentation in real mode ensures compatibility with early x86 processors and operating systems, allowing them to run on modern hardware in a compatible mode.

Limitations

• No Protection: There is no memory protection in real mode. Any program can read or write to any part of the memory, leading to potential system crashes or data corruption.
• Limited Memory: The maximum addressable memory is limited to 1 MB, which is significantly less compared to modern addressing capabilities.
• Complex Address Calculation: The need to combine segment and offset values can complicate address calculations and program logic.

2 Segmentation in Protected Mode (32-Bit)

Protected mode was introduced with the Intel 80286 processor, bringing significant enhancements over real mode, including the ability to address more memory, improved performance, and critical features like memory protection.

In protected mode, Memory is flat, yet segmentation is still technically present, but with some protection.

• Extended Address Space: Protected Mode supports a 32-bit address space, allowing access to 4GB of memory.
• Flat Memory Model: In the flat memory model, the entire memory appears as a single continuous address space, typically from address 0x00000000 to 0xFFFFFFFF (4 GB in 32-bit mode).
• Memory Protection: Segmentation in protected mode enables the implementation of access controls, ensuring that only authorized access to memory segments is allowed.

Memory Protection

Segmentation works differently in protected mode. Segmentation in protected mode provides robust memory protection by enforcing access rights and segment limits. Although the memory is flat in protected mode which is also known as the linear memory model, is a way of organizing memory in a computer system where the entire addressable memory space is treated as a single, continuous block.

Each segment can have different permissions and properties, such as:

• Executable (Code Segment)
• Writable (Data Segment)
• Readable (Code/Data Segment)

Accessing a segment in a way that violates its access rights (e.g., writing to a read-only segment) triggers a general protection fault, preventing unauthorized memory access.

Difference Between Segmentation in Real Mode and Protected Mode:

Explanation:

• Purpose: Real mode primarily extends the 16-bit address space of early x86 processors, while protected mode focuses on memory protection, multitasking, and enhanced security.
• Memory Model: Real mode uses segmented memory model where segments are up to 64 KB in size, while protected mode operates with a flat memory model, treating memory as a continuous linear address space.
• Address Calculation: In real mode, physical addresses are calculated by combining segment and offset directly. In protected mode, segment descriptors in the GDT or LDT are used for address translation to obtain linear addresses.
• Memory Access: Real mode is limited to 1 MB of physical memory, while protected mode allows access to up to 4 GB in 32-bit mode and much larger in 64-bit mode.
• Segment Registers: Real mode has fewer segment registers (CS, DS, SS, ES), whereas protected mode includes additional registers (FS, GS) for extended functionality.
• Descriptor Tables: Real mode has no descriptor tables; protected mode uses the GDT and optionally LDT to store segment descriptors.
• Memory Protection: Protected mode offers robust memory protection through segment descriptors defining access rights and privilege levels, which real mode lacks.
• Privilege Levels: Protected mode supports different privilege levels (Ring 0 for kernel, Ring 1-3 for user modes), enabling secure multitasking and system management.
• Operating Mode: Real mode operates as a single mode, whereas protected mode supports multitasking with task switching and supports handling interrupts and exceptions more securely.
• Compatibility: Real mode is used by legacy applications and operating systems like DOS, while protected mode is essential for modern operating systems (Windows, Linux) and supports backward compatibility.