/* Début de corrigé de la partie 2
 *
 * Ce programme partage un tableau de 32 pages entre 2 process
 * par des tubes un fork.
 * Chaque page a un attribut INVALID ou READWRITE.
 * Chaque attribut et mprotect est protegé par un mutex pour
 * éviter des race conditions.
 */

#define _GNU_SOURCE /* a garder TOUT EN HAUT du fichier */

#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <malloc.h>
#include <sys/mman.h>
#include <ucontext.h>
#include <signal.h>
#include <pthread.h>
#include <assert.h>
#include <sys/types.h>
#include <sys/wait.h>

#define PAGE_SIZE 4096
#define PAGES 32

#define BASEVAL 50
#define ITERATIONS 100

enum status {
  INVALID,
  READONLY,
  READWRITE,
};

struct pageattr {
  enum status status;
};

static char *buffer;
static struct pageattr attr[PAGES];
static pthread_mutex_t mutex[PAGES];

static int fd_outreq;	/* where I send my requests to the other process */
static int fd_inresp;	/* where I receive the other process responses to my requests */
static int fd_inreq;	/* where I receive requests from the other process */
static int fd_outresp;	/* where I send responses to the other process requests */

static void * thread_func(void *data)
{
  char c;

  printf("[%d] thread starting\n", getpid());

  while (read(fd_inreq, &c, 1) == 1) {
    int index = c;
    char *page = buffer+index*PAGE_SIZE;
//    printf("[%d] got need page %x request\n", getpid(), c);

    pthread_mutex_lock(&mutex[index]);
    write(fd_outresp, page, PAGE_SIZE);
    mprotect(page, PAGE_SIZE, PROT_NONE);
    attr[index].status = INVALID;
    pthread_mutex_unlock(&mutex[index]);
  }

  printf("[%d] thread exiting\n", getpid());
  return NULL;
}

static void segv_handler(int sig, siginfo_t *info, void *_context)
{
  ucontext_t *context = _context;
//  int writeaccess = (context->uc_mcontext.gregs[REG_ERR] & 2);
#ifdef __x86_64__
  void *addr = (void *)(context->uc_mcontext.gregs[REG_CR2]);
#elif __i386__
  void *addr = (void *)(context->uc_mcontext.cr2);
#else
#error Architecture non support?e
#endif
  char *page  = (void *)(((unsigned long) addr) & ~(PAGE_SIZE-1));
  int index = (page-buffer)/PAGE_SIZE;

  pthread_mutex_lock(&mutex[index]);
  if (attr[index].status == INVALID) {
    char c = index;
//    printf("[%d] sending need page %x request\n", getpid(), index);
    write(fd_outreq, &c, 1); /* request the page */
    mprotect(page, PAGE_SIZE, PROT_READ|PROT_WRITE);
    attr[index].status = READWRITE;
    read(fd_inresp, page, PAGE_SIZE);
  }
  pthread_mutex_unlock(&mutex[index]);
}

int main(int argc, char *argv[])
{
  int pipes[8];
  struct sigaction act;
  pthread_t thread;
  pid_t pid;
  int i,j;
  int ret;

  buffer = memalign(PAGE_SIZE, PAGE_SIZE*PAGES);
  if (!buffer) {
    printf("failed to malloc\n");
    exit(-1);
  }

  /* initialise les donnees */
  for(i=0; i<PAGES; i++)
    *(int*)(buffer+i*PAGE_SIZE) = i + BASEVAL;

  ret = mprotect(buffer, PAGE_SIZE*PAGES, PROT_NONE);
  if (ret < 0) {
    printf("failed to mprotect\n");
    exit(-1);
  }
  for(i=0; i<PAGES; i++)
    attr[i].status = INVALID;

  act.sa_flags = SA_SIGINFO;
  act.sa_sigaction = segv_handler;
  sigaction(SIGSEGV, &act, NULL);

  ret = pipe(&pipes[0]); /* first pipe to send requests from first process */
  if (ret < 0) {
    perror("pipe1");
    exit(-1);
  }
  ret = pipe(&pipes[2]); /* second pipe to recv responses to first process requests */
  if (ret < 0) {
    perror("pipe2");
    exit(-1);
  }
  ret = pipe(&pipes[4]); /* third pipe to send requests from second process */
  if (ret < 0) {
    perror("pipe3");
    exit(-1);
  }
  ret = pipe(&pipes[6]); /* fourth pipe to recv responses to second process requests */
  if (ret < 0) {
    perror("pipe4");
    exit(-1);
  }

  for(i=0; i<PAGES; i++)
    pthread_mutex_init(&mutex[i], NULL);

  pid = fork();
  if (pid) {
    /* pere */

    close(pipes[0]);
    fd_outreq = pipes[1];
    fd_inresp = pipes[2];
    close(pipes[3]);
    fd_inreq = pipes[4];
    close(pipes[5]);
    close(pipes[6]);
    fd_outresp = pipes[7];

    /* on donne les pages paires au pere */
    for(i=0; i<PAGES; i+=2) {
      attr[i].status = READWRITE;
      mprotect(buffer+i*PAGE_SIZE, PAGE_SIZE, PROT_READ|PROT_WRITE);
    }

    ret = pthread_create(&thread, NULL, thread_func, NULL);
    if (ret < 0) {
      perror("pthread_create");
      exit(-1);
    }
    sleep(1);

    /* on incremente toutes les valeurs plein de fois */
    for(j=0; j<ITERATIONS; j++)
      for(i=0; i<PAGES; i++)
	(*(int*)(buffer+i*PAGE_SIZE))++;

    /* on attend un peu pour que l'autre soit arrivé la aussi, puis on print */
    sleep(1);
    for(i=0; i<PAGES; i++)
      printf("[%d] pere voit page %d qui contient %d (%d attendu)\n", getpid(), i, *(int*)(buffer+i*PAGE_SIZE), i+BASEVAL+ITERATIONS*2);
    /* on reattend, afin de pas exiter tout de suite, sinon on pourrait pas rendre les pages a l'autre */
    sleep(1);

    printf("[%d] join le fils\n", getpid());
    waitpid(pid, NULL, 0);

  } else {
    /* fils */

    fd_inreq = pipes[0];
    close(pipes[1]);
    close(pipes[2]);
    fd_outresp = pipes[3];
    close(pipes[4]);
    fd_outreq = pipes[5];
    fd_inresp = pipes[6];
    close(pipes[7]);

    /* on donne les pages impaires au fils */
    for(i=1; i<PAGES; i+=2) {
      attr[i].status = READWRITE;
      mprotect(buffer+i*PAGE_SIZE, PAGE_SIZE, PROT_READ|PROT_WRITE);
    }

    ret = pthread_create(&thread, NULL, thread_func, NULL);
    if (ret < 0) {
      perror("pthread_create");
      exit(-1);
    }
    sleep(1);

    /* on incremente toutes les valeurs plein de fois */
    for(j=0; j<ITERATIONS; j++)
      for(i=0; i<PAGES; i++)
	(*(int*)(buffer+i*PAGE_SIZE))++;

    /* on attend un peu pour que l'autre soit arrivé la aussi, puis on print */
    sleep(1);
    for(i=0; i<PAGES; i++)
      printf("[%d] fils voit page %d qui contient %d (%d attendu)\n", getpid(), i, *(int*)(buffer+i*PAGE_SIZE), i+BASEVAL+ITERATIONS*2);
    /* on reattend, afin de pas exiter tout de suite, sinon on pourrait pas rendre les pages a l'autre */
    sleep(1);
  }

  return 0;
}