Unable to call sem_trywait function in consumer process while able to get POSIX semaphore value

I am currently trying to solve issue with my multi-process project. In the process called sender(file sender.c, producer) I am able to modify unnamed semaphore value bu using sem_wait and sem_post functions, POSIX sempahore is in shared memory. Curiously, in the process called receiver.c(consumer), I am able to get semaphore value, but calling sem_trywait gives me segmentation fault error.

I am suspecting some issues with passing arguments(pass-by-reference vs. pass-by-value). Other cause of issue might be due to improper way of releasing/destroing semaphore - i am aware that currently this issue might not be solved properly. Both sender.c and receiver.c get the data structure (buffer_node struct) from static linking.

I tested that code on both Ubuntu running on x64 processor and Raspbian(Raspberry PI) running on ARM processor, i also tried changing sem_trywait to sem_wait. Preferably, I would like to avoid changing to named semaphores.

Header file(only struct buffer_node is tested)

    #define _CBUFFAPI_H_

    #include <stdlib.h>     
    #include <signal.h>     
    #include "stdio.h"
    #include <semaphore.h>
    #include <sys/ipc.h>
    #include <sys/shm.h>
    #include <sys/sem.h>
    #include <sys/mman.h>
    #include <assert.h>
    #include <sys/stat.h>      
    #include <fcntl.h>   

    #define BUFFER_SIZE    5
    #define SAMPLES_AMOUNT 240


    struct buffer_node {
        unsigned long int buffered_samples[SAMPLES_AMOUNT];
        sem_t semaphore;
        int sem_val;
    };

    struct cyclic_buffer {
        struct buffer_node buffer_elements[BUFFER_SIZE];
        unsigned int head;
        unsigned int tail;
        unsigned int full;
        unsigned int max;
    };

    /*cyclic_buffer* init_buffer();
    //void buffer_reset(cyclic_buffer* cb);
    //void buffer_free(cyclic_buffer* cb);
    //void buffer_put(cyclic_buffer* cb, unsigned int index);
    //unsigned int is_buffer_full(cyclic_buffer* cb);*/
    int get_sem_val(sem_t sem);

    #endif

Sender process:

    #include <stdlib.h>     
    #include <signal.h>     
    #include "stdio.h"
    #include <semaphore.h>
    #include "cbuffapi.h"
    #include <sys/ipc.h>
    #include <sys/shm.h>
    #include <sys/sem.h>
    #include <sys/mman.h>
    #include <unistd.h>
    #include <sys/types.h>
    #include <assert.h>
    #include <sys/stat.h>      
    #include <fcntl.h>   

    #define NAME           "/testmem"

    struct buffer_node * shm_buffer;

    void Handler(int signo)
    {
        //System Exit
        printf("\r\n END \r\n");
        sem_close(&(shm_buffer->semaphore));
        munmap(0, sizeof(struct buffer_node));
        shm_unlink(NAME);
        exit(0);
    }

    int main()
    {
        signal(SIGINT, Handler);
        int shm_cyclic_buffer_fd = shm_open(NAME, O_CREAT|O_RDWR|O_EXCL, 0666);
    
        if(shm_cyclic_buffer_fd < 0)
        {
            perror("shm_open()");
            return 1;
        }
    
        ftruncate(shm_cyclic_buffer_fd, sizeof(struct buffer_node));
        shm_buffer = (struct buffer_node*)mmap(0, sizeof(struct buffer_node), PROT_WRITE|PROT_READ,    MAP_SHARED, shm_cyclic_buffer_fd, 0);
    shm_buffer->sem_val = 67;
    sem_init(&(shm_buffer->semaphore), 1, 4);
    int test_sem_val = 15;
    
    while(1)
    {
	if(sem_trywait(&(shm_buffer->semaphore))==0)
	{
	    sem_getvalue(&(shm_buffer->semaphore), &test_sem_val);
	    printf("%d\n", test_sem_val);
	    shm_buffer->sem_val = shm_buffer->sem_val + 1;
	    printf("%d\n", shm_buffer->sem_val);
	    sleep(5);
	    sem_post(&(shm_buffer->semaphore));
	    sem_getvalue(&(shm_buffer->semaphore), &test_sem_val);
	    printf("%d\n", test_sem_val);
	}
	else if(sem_trywait(&(shm_buffer->semaphore))== -1)
	{	
	    printf("variable reading - overwriting impossible\n");
	}
	
	sleep(0.5);
    }
    return 0;
}

Receiver process:

#include <stdlib.h>     
#include <signal.h>     
#include "stdio.h"
#include <semaphore.h>
#include "cbuffapi.h"
#include <sys/ipc.h>
#include <sys/shm.h>
#include <sys/sem.h>
#include <sys/mman.h>
#include <unistd.h>
#include <sys/types.h>
#include <assert.h>
#include <sys/stat.h>      
#include <fcntl.h>   

#define NAME           "/testmem"

int shared_memory_fd;
void Handler(int signo)
{
    //System Exit
    printf("\r\n END \r\n");
    munmap(0, sizeof(struct buffer_node));
    close(shared_memory_fd);
    shm_unlink(NAME);
    exit(0);
}

int main()
{
    signal(SIGINT, Handler);
    struct buffer_node* shm_buffer;
	
    int shared_memory_fd = shm_open(NAME, O_RDONLY, 0666);
	
    if(shared_memory_fd < 0)
    {
	perror("Impossible to get shared memory file descriptor");
	return 1;
    }
    printf("Shared memory ID ok\n");
    //memory mapping
    shm_buffer=(struct buffer_node*)mmap(0, sizeof(struct buffer_node), PROT_READ, MAP_SHARED, shared_memory_fd, 0);
	
    if(shm_buffer == (void *) -1)
    {
	perror("Cannot attach to shared memory");
	return 2;
    }
    printf("map ok");
    printf("shared memory ID ok\n");
    int test_sem_val = 1;

    while(1)
    {
	sem_getvalue(&(shm_buffer->semaphore), &test_sem_val);
	printf("%d\n", test_sem_val);
	printf("%d\n", shm_buffer->sem_val);
	sleep(5);
	if(sem_trywait(&(shm_buffer->semaphore)) == 0)
	{	
	    printf("%d\n", shm_buffer->sem_val);
	    sleep(1);
	    sem_post(&(shm_buffer->semaphore));
	}
	else
	{
	    printf("variable modified\n");
	    sleep(1);
	}
    }
    return 0;
}

Any help would be appreciated.

The receiver process is opening the shared memory object in read-only mode (O_RDONLY) and the object is being mapped by mmap() with read-only protection (PROT_WRITE is not set).

The shared memory contains a valid sem_t semaphore object, but because the memory is read-only in the receiver process, any attempts by the receiver process to modify the semaphore object will result in a SIGSEGV signal being delivered to the process. The default action for that signal is to terminate the process with a core dump.

The sem_wait(), sem_trywait(), sem_timedwait() and sem_post() functions all require write access to the semaphore. The sem_getvalue() function only requires read access to the semaphore.