mremap系统调用及示例

#define _GNU_SOURCE // 需要定义此宏以使用 mremap
#include <sys/mman.h> // 必需

void *mremap(void *old_address, size_t old_size, size_t new_size, int flags, ... /* void *new_address */);

#define _GNU_SOURCE // 必须定义以使用 mremap
#include <sys/mman.h> // mmap, munmap, mremap
#include <stdio.h>    // perror, printf
#include <stdlib.h>   // exit
#include <string.h>   // strcpy, strlen
#include <unistd.h>   // getpagesize

int main() {
    size_t initial_size = 4096; // 1 页
    size_t larger_size = 12288; // 3 页
    size_t smaller_size = 2048; // 半页多一点
    char *mapped_memory;
    char *new_mapped_memory;

    printf("Page size: %ld bytes\n", (long)getpagesize());

    // 1. 创建初始的匿名内存映射
    mapped_memory = mmap(NULL, initial_size, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
    if (mapped_memory == MAP_FAILED) {
        perror("mmap initial");
        exit(EXIT_FAILURE);
    }
    printf("Initial mapping: %p - %p (Size: %zu bytes)\n",
           (void*)mapped_memory, (char*)mapped_memory + initial_size - 1, initial_size);

    // 2. 在初始映射中放入一些数据
    const char *initial_data = "Initial data in the mapped region.";
    size_t data_len = strlen(initial_data);
    if (data_len < initial_size) {
        strcpy(mapped_memory, initial_data);
        printf("Written initial data: '%s'\n", mapped_memory);
    }

    // --- 3. 扩展映射区域 ---
    printf("\n--- Expanding mapping ---\n");
    // MREMAP_MAYMOVE: 允许内核移动映射
    new_mapped_memory = mremap(mapped_memory, initial_size, larger_size, MREMAP_MAYMOVE);
    if (new_mapped_memory == MAP_FAILED) {
        perror("mremap expand");
        // 清理并退出
        munmap(mapped_memory, initial_size);
        exit(EXIT_FAILURE);
    }
    // 关键：使用 mremap 返回的新地址！
    mapped_memory = new_mapped_memory;
    printf("Expanded mapping: %p - %p (Size: %zu bytes)\n",
           (void*)mapped_memory, (char*)mapped_memory + larger_size - 1, larger_size);

    // 4. 验证初始数据是否还在 (通常会在)
    printf("Data after expansion: '%s'\n", mapped_memory);

    // 5. 在扩展后的区域写入新数据
    const char *new_data = "New data written after expansion!";
    size_t new_data_len = strlen(new_data);
    // 写入到扩展区域的后面部分
    if (initial_size + new_data_len < larger_size) {
        strcpy(mapped_memory + initial_size, new_data);
        printf("Written new data at offset %zu: '%s'\n", initial_size, mapped_memory + initial_size);
    }


    // --- 6. 收缩映射区域 ---
    printf("\n--- Shrinking mapping ---\n");
    new_mapped_memory = mremap(mapped_memory, larger_size, smaller_size, MREMAP_MAYMOVE);
    if (new_mapped_memory == MAP_FAILED) {
        perror("mremap shrink");
        // 清理并退出
        munmap(mapped_memory, larger_size); // 使用旧大小清理
        exit(EXIT_FAILURE);
    }
    // 再次更新地址
    mapped_memory = new_mapped_memory;
    printf("Shrunk mapping: %p - %p (Size: %zu bytes)\n",
           (void*)mapped_memory, (char*)mapped_memory + smaller_size - 1, smaller_size);

    // 7. 尝试访问收缩后仍在范围内的数据
    printf("First %zu characters after shrinking: ", (smaller_size < 100) ? smaller_size : 100);
    for (size_t i = 0; i < smaller_size && i < 100; ++i) {
        putchar(mapped_memory[i]);
    }
    printf("\n");

    // 8. 尝试访问被收缩掉的部分 (会导致段错误 Segmentation fault)
    // printf("Trying to access data beyond new end...\n");
    // char c = mapped_memory[initial_size]; // 例如，访问原来初始数据之后的位置
    // printf("Accessed character (should not happen): %c\n", c);
    // 为了避免崩溃，注释掉上面两行。取消注释会导致程序崩溃。


    // --- 9. 清理 ---
    if (munmap(mapped_memory, smaller_size) == -1) {
        perror("munmap final");
    }

    printf("\nMemory unmapped successfully.\n");
    return 0;
}

#define _GNU_SOURCE
#include <sys/mman.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>

int main() {
    size_t size1 = 4096;
    size_t size2 = 8192;
    char *map1, *map2, *remapped_map;

    // 1. 创建第一个映射
    map1 = mmap(NULL, size1, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
    if (map1 == MAP_FAILED) {
        perror("mmap map1");
        exit(EXIT_FAILURE);
    }
    printf("Map1 created at: %p\n", (void*)map1);
    strcpy(map1, "Data in Map1");

    // 2. 创建第二个映射 (紧随第一个之后创建，地址可能相邻)
    map2 = mmap(NULL, size1, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
    if (map2 == MAP_FAILED) {
        perror("mmap map2");
        munmap(map1, size1);
        exit(EXIT_FAILURE);
    }
    printf("Map2 created at: %p\n", (void*)map2);
    strcpy(map2, "Data in Map2");

    // 3. 尝试扩展 map1。如果 map2 紧跟在 map1 后面，原地扩展可能失败。
    printf("\n--- Attempting to expand Map1 ---\n");
    printf("Map1 range: %p - %p\n", (void*)map1, (char*)map1 + size1 - 1);
    printf("Map2 range: %p - %p\n", (void*)map2, (char*)map2 + size1 - 1);

    // 检查是否相邻 (简化检查)
    if ((char*)map1 + size1 == (char*)map2) {
        printf("Map1 and Map2 are adjacent. Expansion might require moving.\n");
    }

    // 尝试扩展 map1
    remapped_map = mremap(map1, size1, size2, MREMAP_MAYMOVE);
    if (remapped_map == MAP_FAILED) {
        perror("mremap map1");
        munmap(map1, size1);
        munmap(map2, size1);
        exit(EXIT_FAILURE);
    }

    // 4. 检查地址是否改变
    if (remapped_map != map1) {
        printf("Map1 was MOVED by mremap!\n");
        printf("  Old address: %p\n", (void*)map1);
        printf("  New address: %p\n", (void*)remapped_map);
    } else {
        printf("Map1 was expanded IN PLACE.\n");
        printf("  Address remains: %p\n", (void*)remapped_map);
    }
    printf("New Map1 range: %p - %p (Size: %zu)\n",
           (void*)remapped_map, (char*)remapped_map + size2 - 1, size2);

    // 5. 验证数据 (如果移动了，数据应该被复制)
    printf("Data in (new) Map1: '%s'\n", remapped_map);

    // 6. 原来的 map1 指针现在无效了，不要再使用
    // printf("Trying to access old map1 pointer... "); // 不要这样做
    // printf("%s\n", map1); // 危险！

    // 7. 清理所有映射
    // 使用新的地址和大小清理 map1
    if (munmap(remapped_map, size2) == -1) {
        perror("munmap remapped_map");
    }
    // 清理 map2
    if (munmap(map2, size1) == -1) {
        perror("munmap map2");
    }

    printf("\nAll mappings cleaned up.\n");
    return 0;
}