Изменить размер у POSIX shared memory сегмента

// Размер динамического массива в разделяемой памяти
uint_fast64_t facts_size = 1;
// Массив
float *array = NULL;
 
// Дескриптор для разделяемой памяти
int shm = 0;
 
// Выделение разделяемой памяти
array = shm_alloc(&size,name,&shm);
 
float *shm_alloc(uint_fast64_t *size, const char *name, int *shm){
 
    int mode = O_CREAT|O_RDWR;
    float *array = NULL;
 
    // Имя области разделяемой памяти
    const char *shared_memory_object_name = name;
 
    // Время для замера длительности в миллисекундах
    long long remember_the_time = 0;
 
    printf("Резерование разделяемой памяти");
    fflush(stdout);
    remember_the_time=time_ms();
 
    if (((*shm) = shm_open(shared_memory_object_name, mode, 0600)) == -1) {
        fprintf(stderr, "shm_open error: %s\n", strerror(errno));
        exit (EXIT_FAILURE);
    }
 
    if (ftruncate((*shm), (*size)*sizeof(float)) == -1){
        fprintf(stderr, "ftruncate error: %s\n", strerror(errno));
        exit (EXIT_FAILURE);
    }
 
    array = mmap(0, (*size)*sizeof(float), PROT_WRITE|PROT_READ, MAP_SHARED, (*shm), 0);
    if (array == (float*)-1) {
        fprintf(stderr, "mmap error: %s\n", strerror(errno));
        exit (EXIT_FAILURE);
    }
    printf(" завершено за %lldms\n",time_ms()-remember_the_time);
 
    // Возврат значения
    return(array);
}

size++;
shm_realloc(array,&size,&shm);
 
void shm_realloc(float *array, uint_fast64_t *size, int *shm){
 
    if (ftruncate((*shm), (*size)*sizeof(float)) == -1){
        fprintf(stderr, "ftruncate error: %s\n", strerror(errno));
        exit (EXIT_FAILURE);
    }
 
    array = mmap(0, (*size)*sizeof(float), PROT_WRITE|PROT_READ, MAP_SHARED, (*shm), 0);
    if (array == (float*)-1) {
        fprintf(stderr, "mmap error: %s\n", strerror(errno));
        exit (EXIT_FAILURE);
    }
}

void shm_realloc(float *array, uint_fast64_t *new_array_size, int *shm){
 
    uint_fast64_t old_array_size = new_array_size-1;
 
    if (ftruncate((*shm), (*new_array_size)*sizeof(float)) == -1){
        fprintf(stderr, "ftruncate error: %s\n", strerror(errno));
        exit (EXIT_FAILURE);
    }
    mremap(array,old_array_size*sizeof(float),(*new_array_size)*sizeof(float), 4000, MREMAP_MAYMOVE);
}

void shm_realloc(float *array, uint_fast64_t *array_size, int *shm){
 
    if (ftruncate((*shm), (*array_size)*sizeof(float)) == -1){
        fprintf(stderr, "ftruncate error: %s\n", strerror(errno));
        exit (EXIT_FAILURE);
    }
    array = mremap(array,((*array_size)-1)*sizeof(float),(*array_size)*sizeof(float),MREMAP_MAYMOVE);
    if(array == MAP_FAILED)
    {
        fprintf(stderr, "mremap error: %s\n", strerror(errno));
    }
}

/* main.c */
#define _GNU_SOURCE
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <fcntl.h>
#include <sys/shm.h>
#include <sys/stat.h>
#include <sys/mman.h>
#include <sys/types.h>
#include <errno.h>
 
int main(void)
{
    size_t size_of_mem = 1024;
    int fd = shm_open("/myregion", O_CREAT | O_RDWR,
                      S_IRWXO | S_IRUSR | S_IWUSR);
    if (fd == -1)
    {
        perror("Error in shm_open");
        return EXIT_FAILURE;
    }
 
    if (ftruncate(fd, size_of_mem) == -1)
    {
        perror("Error in ftruncate");
        return EXIT_FAILURE;
    }
 
    void *shm_address = mmap(0, size_of_mem,
                             PROT_READ | PROT_WRITE | PROT_EXEC,
                             MAP_SHARED, fd, 0);
    if (shm_address == MAP_FAILED)
    {
        perror("Error mmapping the file");
        return EXIT_FAILURE;
    }
 
    /* Increase shard memory */
    for (size_t i=0; i<1024; ++i){
 
        /* Does 8 align memory page? */
        size_t new_size_of_mem = 1024+(8*i);
 
        if (ftruncate(fd, new_size_of_mem) == -1)
        {
            perror("Error in ftruncate");
            return EXIT_FAILURE;
        }
 
        /*
           mremap() works with  aligned memory pages.
           How to properly increase shared memory in this case?
        */
        void *temp = mremap(shm_address, size_of_mem, new_size_of_mem, MREMAP_MAYMOVE);
        if(temp == (void*)-1)
        {
            perror("Error on mremap()");
            return EXIT_FAILURE;
        }
 
        shm_address = temp;
 
        size_of_mem = new_size_of_mem;
 
    }
 
    return 0;
}