Попытка достичь конца связанного списка приводит к ошибке сегмента или бесконечному циклу

Question

Я пытаюсь реализовать свой собственный malloc (), и я пытаюсь разделить узел пополам и ввести «разделенный» узел в связанный список как новый узел. условия, если текущий узел содержит достаточно байтов для нового узла, чтобы я мог разделить больший и использовать его избыточные байты на новом узле. Я использую цикл while для итерации по связанному списку, чтобы найти узел, который может соответствовать новому, но каждый раз, когда я пытаюсь запустить программу, он либо бесконечный цикл, либо вызывает ошибки при условии

while (tail->! = NULL) {// функциональность}

У меня здесь 3 функции. Первый выделяет память:

void *beavalloc(size_t size){
    struct node *curr = sbrk(0);
    struct node *tail = head;//tail and head point at the same node when there is no linked list
    size_t excess = 0;//tracker for excess bytes
    struct node *t = NULL;

if (size <= 0)
    return NULL;
  >>>>>>ERROR LOOP<<<<<<
    while(tail != NULL){
        if (head != NULL && tail->next != NULL)
        {
            t = tail;
            while (t->next != NULL)//SPLITTING FUNCTIONALITY IS BELOW---------------------------------------------------------
            {
                if (t->excess_bytes > size)
                {
                    t->excess_bytes = t->excess_bytes - size;

                    >>>>>CURR->DATA IS NEVER ACCESSED FOR SOME REASON<<<<<
                    curr->data = (struct node *)((t->data + size));

                    initialize_nodes(curr, size, t->excess_bytes);
                    //insert node in the middle of the linked list
                    t->next->prev = curr;
                    curr->next = t->next;
                    t->next = curr;
                    curr->prev = tail;//????????????????????
                    //return (void *)curr->data;
                    return (void *)curr->data;
                }
                else
                {
                    t = t->next;
                }

            }
        }else if(head != NULL && tail->next == NULL){

            if(tail->excess_bytes > size){

                tail->excess_bytes = tail->excess_bytes - size;

                >>>>>CURR->DATA IS NEVER ACCESSED FOR SOME REASON<<<<<
                curr->data = (struct node *)(tail->data + size); //

                initialize_nodes(curr, size, tail->excess_bytes);

                while(tail->next != NULL)
                { //refrenced online code for linked list iteration: https://www.geeksforgeeks.org/doubly-linked-list/
                    tail = tail->next;
                }
                tail->next = curr;
                curr->prev = tail;

                return (void*)curr->data;
            }
        }
        tail = tail->next;
        }
if(size + sizeof(struct node) < MAX_BYTES + 1){

    check_sbrk(sbrk(MAX_BYTES));//check for if sbrk() is working properly
    curr->data = (struct node *)((sbrk(0) - MAX_BYTES) + sizeof(struct node));
    initialize_nodes(curr, size, MAX_BYTES - size);

}//IF THERE ARE MORE BYTES THAN 1024, PUSH 1024 WHILE LOOPING UNTIL BYTES IS LESS THAN 1024----------------------------------------------
else{

    size_t bytes = size + sizeof(struct node);

    while(bytes > MAX_BYTES + 1){//loop until there are less than 1024 bytes to sbrk()

        check_sbrk(sbrk(MAX_BYTES));
        bytes = (bytes - MAX_BYTES); //sunbtract 1024 everytime we allocate 1024 bytes
        excess = (excess + MAX_BYTES);

        if(bytes <= MAX_BYTES){//move out of loop if breaks

            check_sbrk(sbrk(MAX_BYTES));
            bytes -= bytes;
            excess = (excess + MAX_BYTES);
            curr->data = (struct node *)(sbrk(0) - excess + sizeof(struct node));//offset the pointer to point at the beginning of data by subtracting the 
            excess -= size;
            initialize_nodes(curr, size, excess);
        }
    }
}

Вторые / третьи освобождают память и объединяют:

void beavfree(void *ptr){
    struct node *tail = NULL;
    tail = head;

    if(ptr == NULL){
        return;
    }

//----------------------------------------COALESCE SYNTAX BELOW---------------------------------------
    while(tail->next != NULL){
        if (tail->data == ptr)
        {
            if (tail->is_free == TRUE)
            {
                return;
            }
            else
            {
                coalesce_helper(tail);
                return;
            }
        }
        tail = tail->next;
    }
    if(tail->next == NULL){
        coalesce_helper(tail);
        if(tail->prev == NULL){
            tail->excess_bytes = tail->excess_bytes + tail->s; 
        }
        return;

    }
}

void coalesce_helper(struct node *tmp){
    //struct node *save = NULL;
    tmp->is_free = TRUE;

    if (tmp->next != NULL && tmp->next->is_free == TRUE)
    {
        tmp->excess_bytes = tmp->excess_bytes + tmp->next->excess_bytes + tmp->next->s;//merge 
        if (tmp->next->next == NULL)
            tmp->next = NULL;
        else
        {
            tmp->next = tmp->next->next;
            tmp->next->prev = tmp;
        }
            //tmp->len = 0;
    }

    if (tmp->prev != NULL && tmp->prev->is_free == TRUE)
    {
        //save = tmp;
        tmp = tmp->prev;
        tmp->excess_bytes = tmp->excess_bytes + tmp->next->excess_bytes + tmp->next->s;
        if (tmp->next->next == NULL)
            tmp->next = NULL;
        else
        {
            tmp->next = tmp->next->next;
            tmp->next->prev = tmp;

        } 
            //tmp->len = 0;
    }
    tmp->len = 0;
}

Я вызываю эти функции с такими:

 ptr1 = beavalloc(10000);

        beavfree(ptr1);

        ptr1 = beavalloc(100);
        // should force a split
        ptr2 = beavalloc(200);

Кто-нибудь знает, почему цикл while в beavalloc (размер);будет бесконечно зацикливаться или почему данные curr (отмеченные в коде) никогда не будут доступны?

Любая помощь будет оценена. Спасибо.