Producer/Consumer using shared memory

I have the following Producer/Consumer program that works well using pthreads, buffer and semaphores. I want to write the same exact program using fork() (instead of pthreads), shared memory, buffer and semaphores. Thank you in advance for helping.

I consider this question very difficult because I am not familiar with shared memory.

#include <stdio.h>
#include <stdlib.h>
#include <semaphore.h>
#include <pthread.h>

int ** Buffer;
int maximum;
int buffer_pos = 0;
int output_pos = 0;
int times_written = 0;
int bufLength;
sem_t mut;
sem_t empty;
sem_t full;
void *producer(void *thread_num);
void *consumer(void *thread_num);

int main(int argc, char *argv[])
{
      int i, x;
      int max = atoi(argv[1]), pno = atoi(argv[3]), cno = atoi(argv[4]);
      pthread_t tid1[pno];
      pthread_t tid2[cno];
      if(argc != 5)
                {  
            printf("Wrong number of parameters. Please enter 4 parameters.\n");
            exit(1);
                }
      bufLength = atoi(argv[2]);
      maximum = max;
            
      Buffer = (int**) malloc (bufLength * sizeof(int *));
                for (i =0 ; i < bufLength; i++)
            Buffer[i] = malloc (2 * sizeof(int));

      sem_init(&mut, 0, 1);
      sem_init(&full, 0, 0);
      sem_init(&empty, 0, bufLength);
      
      for(i = 0; i < pno; i++)
      {
            x = pthread_create(&tid1[i], NULL, producer, (void *)i+1);
            if (x)
            {                                    
                  printf("ERROR; return code from pthread_create() is %d\n", x);
                exit(-1);
            }
      }
      
      
      
      for(i = 0; i < cno; i++)
      {
            x = pthread_create(&tid2[i], NULL, consumer, (void *)i+1);
            if (x)
            {                                    
                  printf("ERROR; return code from pthread_create() is %d\n", x);
                exit(-1);
            }
      }
      
      for (i = 0; i < pno; i++)
            pthread_join(tid1[i], 0);

      printf("DONE\n");
}

void *producer(void *thread_num)
{
      while (1)
      {
            sem_wait(&empty);
            sem_wait(&mut);
            if (times_written < maximum)
            {
                  if (times_written < bufLength)
                  {
                        Buffer[buffer_pos][0] = times_written + 1;
                        Buffer[buffer_pos][1] = (int)thread_num;
                        buffer_pos++;
                        times_written++;
                  }
                  else if( (times_written % bufLength) == 0)
                  {
                        buffer_pos = 0;
                        Buffer[buffer_pos][0] = times_written + 1;
                        Buffer[buffer_pos][1] = (int)thread_num;
                        buffer_pos++;
                        times_written++;
                  }
                  else
                  {
                        Buffer[buffer_pos][0] = times_written + 1;
                        Buffer[buffer_pos][1] = (int)thread_num;
                        buffer_pos++;;
                        times_written++;
                  }
            }
            else
            {
                  sem_post(&mut);
                  sem_post(&full);
                  pthread_exit(NULL);
            }
            sem_post(&mut);
            sem_post(&full);
            sleep(1);
      }
}

void *consumer(void *thread_num)
{
      while (1)
      {
            sem_wait(&full);
            sem_wait(&mut);
            if (output_pos < times_written)
            {
                  if (output_pos < bufLength)
                  {
                        printf("%d %d %d %d\n", Buffer[output_pos][0], Buffer[output_pos][1], (int)thread_num, output_pos);
                        output_pos++;
                  }
                  else if ( (output_pos % bufLength) == 0)
                  {
                        printf("%d %d %d %d\n", Buffer[0][0], Buffer[0][1], (int)thread_num, output_pos % bufLength);
                        output_pos++;
                  }
                  else
                  {
                        printf("%d %d %d %d\n", Buffer[output_pos % bufLength][0], Buffer[output_pos % bufLength][1], (int)thread_num, output_pos % bufLength);
                        output_pos++;
                  }
            }
            else
            {
                  sem_post(&mut);
                  sem_post(&empty);
                  pthread_exit(NULL);
            }
            sem_post(&mut);
            sem_post(&empty);
            sleep(1);
      }
}