Не удалось выделить память, полученную указателем linux

Приоритет № 1
Посмотрев еще немного на ваш код, я подозреваю, что вы выполняете приведение типов так же часто, как и раньше, потому что постоянно получаете предупреждения компилятора о "несовместимых типах [указателей]". " и тому подобное. Эти предупреждения существуют по какой-то причине: есть проблема, возможный источник ошибок. Не замалчивайте, не игнорируйте: ИСПРАВЬТЕ ЭТО!

Да, иногда эти приведения требуются, а иногда компиляторы жалуются на ваш код, когда вы знаете, что делаете. В этом случае вы можете добавить приведение типов, но не думайте об этих преобразованиях как о приколах компилятора: это способ сообщить компилятору, что вы знаете, что делаете. Вы только что сошли с ума, чтобы заставить компилятор заткнуться. Плохо.

Далее
В обоих вызовах db_read_from_file из main вы передаете указатель на нулевой указатель вашей функции. Это означает, что вам все еще нужно выделить память, чтобы фактически перейти и сохранить эти данные, или вам нужно переопределить holder на что-то вроде:

struct
{
    user_manage_t user_manage;//not pointers, actual structs
    user_manage_t user_manage_backup;
} holder;

Если вы сохраните их как указатели, просто выделите все члены holder в main:

holder.user_manage = malloc(sizeof *holder.user_manage);//and so on
//preferably, though:
if (NULL == (holder.user_manage_backup = malloc(sizeof *holder.user_manage_backup))
    exit (EXIT_FAILURE);//error

Большой
Как уже упоминалось:

memcpy( (struct user_manage_t *) &prt, &buffer, 90); 

Вы проезжаете мимо &prt, который гласит: адрес prt. Эта переменная сама по себе уже является указателем, адрес памяти указателя — это опять же указатель. Указатель на указатель (двойная косвенность, по возможности избегайте...). Теперь, как будто этого было недостаточно: посмотрите, что вы передаете своей функции:

db_read_from_file(&holder.user_manage);

Имейте в виду, что holder.user_manage уже является указателем, вы передаете указатель на указатель! Это двойная косвенность. Затем вы передаете указатель на этот указатель указателю на memcpy!! Да, возможно, вам придется прочитать это последнее предложение еще раз. Но вкратце: вы передаете указатель на указатель, на указатель на структуру, где этот последний бит (указатель на структуру) тоже может быть просто нулевым указателем!

Итак, что у вас есть:

memcpy(void ***, char *, 90);//where the prt is void ***, and **prt could be NULL

Думайте о memcpy как о функции, которая в основном делает следующее:

void * memcpy( void *target, const void *src, size_t nr_of_bytes)
{
    char *dest = target;
    char *from = src;//use char, as it is guaranteed to be 1 byte in size
    int i;
    while(nr_of_bytes--)
        *dest++ = *from++;//copy byte to destination, move pointer 1 byte
    return dest;//return destination
}

Обратите внимание, что место назначения разыменовано (*dest++). Если вы передадите указатель на указатель (&prt) и разыменуете его, вы получите указатель, верно? Это то, что вы пишете => *(&prt) == prt!

Приведение и то, как вы его используете, предполагает, что вы считаете, что пишете то, на что указывает prt, в то время как на самом деле вы пытаетесь записать 90 байтов на то, на что указывает указатель на prt. И он указывает на prt, который, в свою очередь, указывает на указатель. Только после этого третьего обращения мы находим структуру... это просто безумие.
В любом случае, размер указателя составляет 4 байта в 32-битной системе и 8 в 64-битной. Вы копируете 90 байт, так что вы, вероятно, окажетесь в памяти, с которой не стоит связываться.

Замените свой код на этот:

memcpy(*prt, buffer, sizeof *prt);//copy max the sizeof whatever prt is pointing to

И измените функцию db_read_from_file на это:

int db_read_from_file(user_manage_t **prt)//pointer to pointer!

И имейте в виду, что всякий раз, когда вы хотите изменить что-то в структуре, на которую указывает prt (2-й уровень), вы должны разыменовать ее, чтобы получить обычный указатель. Например, выделение памяти:

if ( NULL == ( prt = calloc( 10, sizeof(user_manage_t))))//aloca

Должен стать:

if ( NULL == ( *prt = calloc( 10, sizeof(user_manage_t))))//aloca

Тем не менее, это все еще неправильно во многих отношениях. Что вам действительно нужно, так это realloc, потому что prt может уже указывать на выделенную память:

*prt = realloc(*prt, 10*sizeof **prt);
if (*prt == NULL)
    //ERROR

Это чище и безопаснее.

Также проверяйте, не передается ли вашей функции нулевой указатель, избавляйтесь от ненужных приведений (они бесполезны) и всегда проверяйте возвращаемое значение функций!

Вот окончательный код, на случай, если кто-то споткнется в подобной ситуации:

typedef struct user_manage_t{

short int user_id;
char permission;
long int other_id;
long int check;

}user_manage_t;

структура typedefholder_t{

user_manage_t *user_manage;
user_manage_t *user_manage_backup;
pthread_mutex_t check_mutex;
pthread_mutex_t backup_mutex;
//(...)and a lot of stuff

}holder_t;

держатель_t держатель;

int db_read_from_file(user_manage_t **prt, pthread_mutex_t mtx){

DEBUG_PRINT("READ_FROM file started");
FILE *fd_read;
char buffer[480];
int read, bytesRead=0; 
int num;
const  struct user_manage_t *header;
fd_read = fopen("/home/user/user_list","r+b");   
if (fd_read == NULL) 
{
    printf("Error");
}
else
{
    DEBUG_PRINT("Its open!!!");
}
do 
{
    read=fread(buffer, 1, 480, fd_read);
    bytesRead=bytesRead+read;   
    DEBUG_PRINT("Number of bytes lidos read=%d",read);
}while(read!=0); //(bytesRead < 480);
header = (struct  user_manage_t *) (buffer);
fclose(fd_read);
if ( NULL != prt )
{
   status = pthread_mutex_trylock (&mtx);
   if (status != 0)//compor isto
   {
         DEBUG_PRINT("ERROR with lock");
         return -1;
   }
   else
   {
        num = bytesRead / sizeof(user_manage_t);
        DEBUG_PRINT("prt is not null and num=%d",num);
        //should add an if to check if num >0
        //if ( NULL == ( *prt = calloc( num, sizeof(user_manage_t))))//aloca
        if ( NULL == ( *prt = malloc(bytesRead)))
        {    
             DEBUG_PRINT("MAJOR_ERROR: couldnt allocate mem to users");
             status = pthread_mutex_unlock(&mtx);
             return -1;
        }
        else
        {
             //memcpy( *prt, header, sizeof(**prt));    
             memcpy( *prt, header, bytesRead); 
             DEBUG_PRINT("Users copied to main list");
             status = pthread_mutex_unlock(&mtx);                 
             for ( short int i=0;i<4 ; i++ )
             {
                 DEBUG_PRINT("i= %hd",i);
                 DEBUG_PRINT("User id: %d",holder.user_manage[i].user_id );
                 DEBUG_PRINT("Permission: %d",holder.user_manage[i].permission);
                 DEBUG_PRINT("other_ID:%ld",holder.user_manage[i].other_id);
                 DEBUG_PRINT("Check_value:%ld", holder.user_manage[i].check);
             }
             return 1;
        }
    }
}
if ( NULL == prt )
{
    DEBUG_PRINT("Pointer is null!");
    return 0;
}

}

главный(){

    db_read_from_file(&holer.user_manage, holder.check_mutex);  
    db_read_from_file(&holder.user_manage_backup, holder.backup_mutex);

}

Я не уверен, хорошо ли я проверяю null prt, но остальное работает. Я внес небольшие изменения, чтобы быть «идеальным», отсутствует только одна вещь: это отправка имени файла в качестве входных данных функции. Похоже, мьютекс работает со 100% уверенностью.