内存管理与虚拟内存

// 页表项结构定义
typedef struct {
    unsigned long pte;
} pte_t;

// 页目录项结构定义
typedef struct {
    unsigned long pde;
} pde_t;

// 页表项操作
static inline pte_t pte_mkwrite(pte_t pte)
{
    pte.pte |= _PAGE_RW;
    return pte;
}

static inline pte_t pte_mkread(pte_t pte)
{
    pte.pte |= _PAGE_USER;
    return pte;
}

// 页表查找
static inline pte_t *pte_offset_kernel(pmd_t *pmd, unsigned long address)
{
    return (pte_t *)pmd_page_vaddr(*pmd) + pte_index(address);
}

// 缺页中断处理函数
dotraplinkage void do_page_fault(struct pt_regs *regs, unsigned long error_code)
{
    unsigned long address = read_cr2(); /* 获取触发缺页的地址 */
    struct vm_area_struct *vma;
    struct mm_struct *mm;
    int fault;
    
    mm = current->mm;
    
    // 查找虚拟内存区域
    vma = find_vma(mm, address);
    if (!vma) {
        bad_area(regs, error_code, address);
        return;
    }
    
    // 检查访问权限
    if (vma->vm_start <= address) {
        good_area(regs, error_code, address);
        return;
    }
    
    // 处理缺页
    fault = handle_mm_fault(vma, address, flags);
    
    if (fault & VM_FAULT_ERROR) {
        if (fault & VM_FAULT_OOM)
            pagefault_out_of_memory();
        else if (fault & VM_FAULT_SIGBUS)
            do_sigbus(regs, error_code, address);
        return;
    }
}

// SLAB分配器结构
struct kmem_cache {
    struct array_cache *array[NR_CPUS];
    unsigned int batchcount;
    unsigned int limit;
    unsigned int shared;
    unsigned int size;
    unsigned int align;
    unsigned int flags;
    const char *name;
    struct list_head next;
    struct kobj_ns_type_operations *kobj_ns_type_operations;
};

// 内存分配函数
void *kmalloc(size_t size, gfp_t flags)
{
    struct kmem_cache *cachep;
    void *ret;
    
    if (unlikely(size > KMALLOC_MAX_CACHE_SIZE))
        return kmalloc_large(size, flags);
    
    cachep = kmalloc_slab(size, flags);
    if (unlikely(ZERO_OR_NULL_PTR(cachep)))
        return cachep;
    
    ret = slab_alloc(cachep, flags, _RET_IP_);
    trace_kmalloc(_RET_IP_, ret, size, cachep->size, flags);
    
    return ret;
}

#include <stdio.h>
#include <stdlib.h>
#include <sys/mman.h>
#include <fcntl.h>
#include <unistd.h>

int main() {
    int fd;
    void *addr;
    size_t size = 4096;  // 4KB
    
    // 创建匿名内存映射
    addr = mmap(NULL, size, PROT_READ | PROT_WRITE, 
                MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
    
    if (addr == MAP_FAILED) {
        perror("mmap");
        exit(1);
    }
    
    printf("映射地址: %p\n", addr);
    
    // 使用映射的内存
    char *str = (char*)addr;
    sprintf(str, "Hello, Memory Mapping!");
    printf("内容: %s\n", str);
    
    // 解除映射
    if (munmap(addr, size) == -1) {
        perror("munmap");
        exit(1);
    }
    
    return 0;
}

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>

void test_malloc() {
    printf("=== malloc测试 ===\n");
    
    // 分配内存
    char *ptr = malloc(1024);
    if (!ptr) {
        perror("malloc");
        return;
    }
    
    printf("分配地址: %p\n", ptr);
    
    // 使用内存
    strcpy(ptr, "Hello, malloc!");
    printf("内容: %s\n", ptr);
    
    // 释放内存
    free(ptr);
    printf("内存已释放\n");
}

void test_mmap() {
    printf("\n=== mmap测试 ===\n");
    
    // 创建文件
    int fd = open("/tmp/test_mmap", O_CREAT | O_RDWR, 0644);
    if (fd == -1) {
        perror("open");
        return;
    }
    
    // 设置文件大小
    if (ftruncate(fd, 4096) == -1) {
        perror("ftruncate");
        close(fd);
        return;
    }
    
    // 内存映射
    void *addr = mmap(NULL, 4096, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
    if (addr == MAP_FAILED) {
        perror("mmap");
        close(fd);
        return;
    }
    
    printf("映射地址: %p\n", addr);
    
    // 使用映射的内存
    char *str = (char*)addr;
    sprintf(str, "Hello, mmap!");
    printf("内容: %s\n", str);
    
    // 同步到文件
    if (msync(addr, 4096, MS_SYNC) == -1) {
        perror("msync");
    }
    
    // 解除映射
    munmap(addr, 4096);
    close(fd);
    printf("mmap测试完成\n");
}

int main() {
    test_malloc();
    test_mmap();
    return 0;
}

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>

// 模拟内存泄漏
void memory_leak() {
    for (int i = 0; i < 1000; i++) {
        char *ptr = malloc(1024);
        if (ptr) {
            // 故意不释放内存，造成泄漏
            sprintf(ptr, "Leaked memory %d", i);
        }
    }
}

// 正常内存管理
void proper_memory_management() {
    for (int i = 0; i < 1000; i++) {
        char *ptr = malloc(1024);
        if (ptr) {
            sprintf(ptr, "Proper memory %d", i);
            free(ptr);  // 正确释放内存
        }
    }
}

int main() {
    printf("PID: %d\n", getpid());
    printf("按回车键开始内存泄漏测试...\n");
    getchar();
    
    memory_leak();
    printf("内存泄漏测试完成\n");
    
    printf("按回车键开始正常内存管理测试...\n");
    getchar();
    
    proper_memory_management();
    printf("正常内存管理测试完成\n");
    
    printf("按回车键退出...\n");
    getchar();
    
    return 0;
}

// page_table_test.c
#include <stdio.h>
#include <stdlib.h>
#include <sys/mman.h>
#include <time.h>

int main() {
    size_t size = 1024 * 1024 * 1024;  // 1GB
    char *ptr = malloc(size);
    
    if (!ptr) {
        perror("malloc");
        return 1;
    }
    
    printf("分配了1GB内存，地址: %p\n", ptr);
    
    // 随机访问内存
    clock_t start = clock();
    for (int i = 0; i < 1000000; i++) {
        int index = rand() % (size - 1);
        ptr[index] = 'A';
    }
    clock_t end = clock();
    
    printf("随机访问时间: %f秒\n", 
           (double)(end - start) / CLOCKS_PER_SEC);
    
    free(ptr);
    return 0;
}