CPU Register State:
Base:  14000
Limit:  1000  (Valid range: 14000 - 15000)

Instruction: LOAD [350]  (Logical Address 350)

1. Check Limit:
   Is 350 < 1000?  YES. (If NO -> Trap: Segmentation Violation)

2. Calculate Physical:
   Physical = Base + Logical
            = 14000 + 350
            = 14350

3. Access Memory:
   Send address 14350 to bus.

// Find first hole large enough
void *first_fit(size_t size) {
    for (block_t *b = free_list; b != NULL; b = b->next) {
        if (b->size >= size) {
            return allocate_from_block(b, size);
        }
    }
    return NULL;  // No fit
}

// Find smallest hole that fits
void *best_fit(size_t size) {
    block_t *best = NULL;
    
    for (block_t *b = free_list; b != NULL; b = b->next) {
        if (b->size >= size) {
            if (best == NULL || b->size < best->size) {
                best = b;
            }
        }
    }
    
    return best ? allocate_from_block(best, size) : NULL;
}

// Find largest hole
void *worst_fit(size_t size) {
    block_t *worst = NULL;
    
    for (block_t *b = free_list; b != NULL; b = b->next) {
        if (b->size >= size) {
            if (worst == NULL || b->size > worst->size) {
                worst = b;
            }
        }
    }
    
    return worst ? allocate_from_block(worst, size) : NULL;
}

State:
[ Process A (128KB) ] [ Free (128KB) ] [ Free (256KB) ] [ Free (512KB) ]

#define MAX_ORDER 11  // 2^11 pages = 8 MB max block

struct free_area {
    struct list_head free_list;
    unsigned long nr_free;
};

struct zone {
    struct free_area free_area[MAX_ORDER];
};

// Allocate 2^order pages
struct page *alloc_pages(unsigned int order) {
    for (int current = order; current < MAX_ORDER; current++) {
        if (!list_empty(&zone->free_area[current].free_list)) {
            // Found a block
            struct page *page = list_first_entry(...);
            
            // Split if necessary
            while (current > order) {
                current--;
                // Add buddy to free list
                struct page *buddy = page + (1 << current);
                list_add(&buddy->lru, 
                         &zone->free_area[current].free_list);
            }
            
            return page;
        }
    }
    return NULL;  // Out of memory
}

// Free 2^order pages
void free_pages(struct page *page, unsigned int order) {
    while (order < MAX_ORDER - 1) {
        struct page *buddy = find_buddy(page, order);
        
        if (!buddy_is_free(buddy, order)) {
            break;  // Can't merge
        }
        
        // Remove buddy from free list
        list_del(&buddy->lru);
        
        // Merge: use lower address as new block
        if (buddy < page) {
            page = buddy;
        }
        order++;
    }
    
    // Add merged block to free list
    list_add(&page->lru, &zone->free_area[order].free_list);
}

// Find buddy address (XOR with block size)
struct page *find_buddy(struct page *page, unsigned int order) {
    unsigned long buddy_idx = page_idx ^ (1 << order);
    return pfn_to_page(buddy_idx);
}

// Create a cache for a specific object type
struct kmem_cache *task_cache = kmem_cache_create(
    "task_struct",           // Name
    sizeof(struct task_struct),  // Object size
    __alignof__(struct task_struct),  // Alignment
    SLAB_PANIC,              // Flags
    init_task_struct         // Constructor
);

// Allocate an object
struct task_struct *task = kmem_cache_alloc(task_cache, GFP_KERNEL);

// Free an object
kmem_cache_free(task_cache, task);

// Page table entry flags
#define PTE_PRESENT   (1 << 0)   // Page is in memory
#define PTE_WRITABLE  (1 << 1)   // Write allowed
#define PTE_USER      (1 << 2)   // User mode access allowed
#define PTE_NX        (1ULL << 63)  // No execute (x86-64)

// Example: Read-only code page
pte = physical_address | PTE_PRESENT | PTE_USER;  // No PTE_WRITABLE

// Example: Stack page (no execute)
pte = physical_address | PTE_PRESENT | PTE_WRITABLE | PTE_USER | PTE_NX;

#include <sys/mman.h>
#include <fcntl.h>

int main() {
    int fd = open("data.bin", O_RDWR);
    
    struct stat st;
    fstat(fd, &st);
    size_t size = st.st_size;
    
    // Map file into memory
    void *addr = mmap(NULL, size,
                      PROT_READ | PROT_WRITE,  // Permissions
                      MAP_SHARED,               // Changes written to file
                      fd, 0);                   // File offset
    
    // Access file like memory
    char *data = (char *)addr;
    data[0] = 'X';  // This modifies the file!
    
    // Force write to disk
    msync(addr, size, MS_SYNC);
    
    // Cleanup
    munmap(addr, size);
    close(fd);
    
    return 0;
}

#include <linux/iommu.h>

// Check if IOMMU is available
if (iommu_present(&pci_bus_type)) {
    // IOMMU is enabled
}

// Allocate IOMMU domain (address space for device)
struct iommu_domain *domain = iommu_domain_alloc(&pci_bus_type);

// Attach device to domain
iommu_attach_device(domain, &pdev->dev);

// Map a page for DMA
dma_addr_t iova = 0x1000;
phys_addr_t paddr = page_to_phys(page);
iommu_map(domain, iova, paddr, PAGE_SIZE, IOMMU_READ | IOMMU_WRITE);

// Device can now DMA to IOVA 0x1000
// IOMMU translates to physical page

// Unmap when done
iommu_unmap(domain, iova, PAGE_SIZE);

// Detach device
iommu_detach_device(domain, &pdev->dev);
iommu_domain_free(domain);