Understanding Logical vs Physical Addresses

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

Memory Layout with Base Register Relocation:
 
Physical Memory:
┌──────────────────────────────────────────────┐
│ 0x00000: Operating System                    │
├──────────────────────────────────────────────┤
│ 0x10000: Program A (Base = 0x10000)          │
│          Logical Addr 0 → Physical 0x10000   │
│          Logical Addr 100 → Physical 0x10100 │
├──────────────────────────────────────────────┤
│ 0x50000: Program B (Base = 0x50000)          │
│          Logical Addr 0 → Physical 0x50000   │
│          Logical Addr 100 → Physical 0x50100 │
├──────────────────────────────────────────────┤
│ 0x90000: Free Memory                         │
└──────────────────────────────────────────────┘
 
Both programs are written as if they start at address 0.
The hardware adds the base value during every memory access.
 
Context Switch:
- When switching from Program A to Program B,
- The OS updates the base register from 0x10000 to 0x50000
- All subsequent memory accesses are automatically relocated

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93

#include <stdio.h>
#include <stdlib.h>
 
// Global variables - Data/BSS segments
int initialized_global = 42;       // Data segment
int uninitialized_global;          // BSS segment
 
void print_addresses() {
    // Local variable - Stack segment
    int stack_var = 100;
    
    // Dynamic allocation - Heap segment
    int *heap_ptr = malloc(sizeof(int));
    *heap_ptr = 200;
    
    printf("=== Logical Address Space Exploration ===
 
");
    
    printf("Text Segment (Code):
");
    printf("  Function print_addresses: %p
 
", (void*)print_addresses);
    
    printf("Data Segment (Initialized Globals):
");
    printf("  initialized_global:       %p
 
", (void*)&initialized_global);
    
    printf("BSS Segment (Uninitialized Globals):
");
    printf("  uninitialized_global:     %p
 
", (void*)&uninitialized_global);
    
    printf("Heap Segment (Dynamic Allocation):
");
    printf("  heap_ptr value:           %p
 
", (void*)heap_ptr);
    
    printf("Stack Segment (Local Variables):
");
    printf("  stack_var:                %p
 
", (void*)&stack_var);
    
    // Demonstrate relative positions
    printf("=== Address Comparison ===
");
    printf("Stack is at higher addresses than Heap: %s
",
           (void*)&stack_var > (void*)heap_ptr ? "Yes" : "No");
    printf("Heap is at higher addresses than BSS:   %s
",
           (void*)heap_ptr > (void*)&uninitialized_global ? "Yes" : "No");
    printf("BSS is at higher addresses than Data:   %s
",
           (void*)&uninitialized_global > (void*)&initialized_global ? "Yes" : "No");
    
    free(heap_ptr);
}
 
/*
 * Sample Output (addresses vary due to ASLR):
 * 
 * === Logical Address Space Exploration ===
 * 
 * Text Segment (Code):
 *   Function print_addresses: 0x55d3a2c00189
 * 
 * Data Segment (Initialized Globals):
 *   initialized_global:       0x55d3a2e03010
 * 
 * BSS Segment (Uninitialized Globals):
 *   uninitialized_global:     0x55d3a2e03014
 * 
 * Heap Segment (Dynamic Allocation):
 *   heap_ptr value:           0x55d3a3a052a0
 * 
 * Stack Segment (Local Variables):
 *   stack_var:                0x7ffeba4c01dc
 * 
 * Notice: Stack addresses start with 0x7ff... (high addresses)
 *         Other segments start with 0x55... (lower addresses)
 */
 
int main() {
    print_addresses();
    return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71

#include <stdio.h>
#include <stdint.h>
 
int main() {
    printf("Pointer size on this system: %zu bytes (%zu bits)
 
",
           sizeof(void*), sizeof(void*) * 8);
    
    printf("=== Theoretical Logical Address Space Sizes ===
 
");
    
    // 32-bit system
    uint64_t addr_space_32 = 1ULL << 32;  // 2^32
    printf("32-bit address space:
");
    printf("  Addresses: %llu
", addr_space_32);
    printf("  Size: %.2f GB
 
", addr_space_32 / (1024.0 * 1024.0 * 1024.0));
    
    // 48-bit (common 64-bit implementation)
    uint64_t addr_space_48 = 1ULL << 48;  // 2^48
    printf("48-bit address space (common x86-64):
");
    printf("  Addresses: %llu
", addr_space_48);
    printf("  Size: %.2f TB
 
", addr_space_48 / (1024.0 * 1024.0 * 1024.0 * 1024.0));
    
    // 57-bit (Intel 5-level paging)
    uint64_t addr_space_57 = 1ULL << 57;  // 2^57
    printf("57-bit address space (5-level paging):
");
    printf("  Addresses: %llu
", addr_space_57);
    printf("  Size: %.2f PB
 
", 
           addr_space_57 / (1024.0 * 1024.0 * 1024.0 * 1024.0 * 1024.0));
    
    printf("Note: Full 64-bit would be 16 EB, but no current system implements this.
");
    printf("The unused high bits are sign-extended, creating 'canonical' addresses.
");
    
    return 0;
}
 
/*
 * Output on a 64-bit system:
 * 
 * Pointer size on this system: 8 bytes (64 bits)
 * 
 * === Theoretical Logical Address Space Sizes ===
 * 
 * 32-bit address space:
 *   Addresses: 4294967296
 *   Size: 4.00 GB
 * 
 * 48-bit address space (common x86-64):
 *   Addresses: 281474976710656
 *   Size: 256.00 TB
 * 
 * 57-bit address space (5-level paging):
 *   Addresses: 144115188075855872
 *   Size: 128.00 PB
 */

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60

/* 
 * Address Generation Example: Following 'x' through the compilation pipeline
 */
 
// SOURCE CODE LEVEL
// Variable 'x' is a name - no address yet
int x = 42;
 
int main() {
    int y = x + 1;  // Reference to 'x'
    return y;
}
 
/*
 * AFTER COMPILATION (Assembly/Object Code):
 * 
 *     .data
 * x:                          ; 'x' is now a symbol
 *     .long   42
 * 
 *     .text
 * main:
 *     movl    x(%rip), %eax   ; Reference to symbol 'x' (relocatable)
 *     addl    $1, %eax
 *     ret
 * 
 * At this stage, 'x' is a symbol that will be resolved to
 * an actual address during linking.
 */
 
/*
 * AFTER LINKING (Executable):
 * 
 * Symbol table shows x is at logical address 0x404020:
 * 
 *     .data
 *     .org 0x404020
 *     .long   42
 * 
 *     .text
 *     .org 0x401000
 * main:
 *     movl    0x404020(%rip), %eax  ; Actual address substituted
 *     addl    $1, %eax              ; (or RIP-relative offset)
 *     ret
 * 
 * The linker assigned address 0x404020 to 'x' within the
 * process's logical address space.
 */
 
/*
 * DURING EXECUTION:
 * 
 * 1. CPU fetches instruction from logical address 0x401000
 * 2. Instruction encodes access to logical address 0x404020
 * 3. CPU presents 0x404020 to the MMU for translation
 * 4. MMU translates to physical address (e.g., 0x7FFFDE404020)
 * 5. Physical memory is accessed; value 42 is retrieved
 * 6. All of this happens transparently to the program
 */

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115

#include <stdio.h>
#include <stdlib.h>
#include <sys/mman.h>
#include <unistd.h>
#include <string.h>
 
void demonstrate_mmap() {
    printf("=== Address Space Manipulation with mmap ===
 
");
    
    // Allocate a new region in our logical address space
    size_t size = 4096 * 1000;  // ~4 MB
    
    void *region = mmap(
        NULL,                   // Let OS choose the address
        size,                   // Size of mapping
        PROT_READ | PROT_WRITE, // Readable and writable
        MAP_PRIVATE | MAP_ANONYMOUS,  // Private, not file-backed
        -1,                     // No file descriptor
        0                       // No offset
    );
    
    if (region == MAP_FAILED) {
        perror("mmap failed");
        return;
    }
    
    printf("mmap allocated region at: %p
", region);
    printf("Region size: %zu bytes
", size);
    
    // The region is now part of our logical address space
    // But physical memory is allocated lazily (on first access)
    
    // Write to the region
    memset(region, 0xAB, 4096);  // Now physical pages are allocated
    printf("Wrote to first page
");
    
    // Change protection to read-only
    if (mprotect(region, size, PROT_READ) == 0) {
        printf("Changed region to read-only
");
    }
    
    // Attempting to write now would cause SIGSEGV:
    // memset(region, 0, 4096);  // CRASH!
    
    // Clean up - remove from logical address space
    if (munmap(region, size) == 0) {
        printf("Unmapped region - address space shrunk
");
    }
    
    // region is now an invalid address - accessing it would crash
}
 
void show_address_space_info() {
    printf("
=== Current Address Space Info ===
 
");
    
    // On Linux, we can read /proc/self/maps
    FILE *maps = fopen("/proc/self/maps", "r");
    if (maps) {
        char line[256];
        printf("%-20s %-5s %-8s %s
", 
               "Address Range", "Perm", "Offset", "Mapping");
        printf("%-20s %-5s %-8s %s
", 
               "-------------", "----", "------", "-------");
        
        int count = 0;
        while (fgets(line, sizeof(line), maps) && count < 15) {
            // Parse and display simplified view
            printf("%s", line);
            count++;
        }
        if (count == 15) {
            printf("... (truncated)
");
        }
        fclose(maps);
    }
}
 
int main() {
    demonstrate_mmap();
    show_address_space_info();
    return 0;
}
 
/*
 * Sample Output:
 * 
 * === Address Space Manipulation with mmap ===
 * 
 * mmap allocated region at: 0x7f5a3c000000
 * Region size: 4096000 bytes
 * Wrote to first page
 * Changed region to read-only
 * Unmapped region - address space shrunk
 * 
 * === Current Address Space Info ===
 * 
 * Address Range        Perm  Offset   Mapping
 * -------------        ----  ------   -------
 * 55e8a5c00000-55e8a5c01000 r--p 00000000 /home/user/a.out
 * 55e8a5c01000-55e8a5c02000 r-xp 00001000 /home/user/a.out
 * ...
 */