// SPDX-License-Identifier: GPL-2.0+
/*
 * Helper functions to sync execution between parent and child processes.
 *
 * Copyright 2018, Thiago Jung Bauermann, IBM Corporation.
 */
#include <stdio.h>
#include <stdbool.h>
#include <semaphore.h>

/*
 * Information in a shared memory location for synchronization between child and
 * parent.
 */
struct child_sync {
 /* The parent waits on this semaphore. */
 sem_t sem_parent;

 /* If true, the child should give up as well. */
 bool parent_gave_up;

 /* The child waits on this semaphore. */
 sem_t sem_child;

 /* If true, the parent should give up as well. */
 bool child_gave_up;
};

#define CHILD_FAIL_IF(x, sync)      \
 do {        \
  if (x) {      \
   fprintf(stderr,     \
    "[FAIL] Test FAILED on line %d\n", __LINE__); \
   (sync)->child_gave_up = true;   \
   prod_parent(sync);    \
   return 1;     \
  }       \
 } while (0)

#define PARENT_FAIL_IF(x, sync)      \
 do {        \
  if (x) {      \
   fprintf(stderr,     \
    "[FAIL] Test FAILED on line %d\n", __LINE__); \
   (sync)->parent_gave_up = true;   \
   prod_child(sync);    \
   return 1;     \
  }       \
 } while (0)

#define PARENT_SKIP_IF_UNSUPPORTED(x, sync, msg)   \
 do {        \
  if ((x) == -1 && (errno == ENODEV || errno == EINVAL)) { \
   (sync)->parent_gave_up = true;   \
   prod_child(sync);    \
   SKIP_IF_MSG(1, msg);    \
  }       \
 } while (0)

int init_child_sync(struct child_sync *sync)
{
 int ret;

 ret = sem_init(&sync->sem_parent, 1, 0);
 if (ret) {
  perror("Semaphore initialization failed");
  return 1;
 }

 ret = sem_init(&sync->sem_child, 1, 0);
 if (ret) {
  perror("Semaphore initialization failed");
  return 1;
 }

 return 0;
}

void destroy_child_sync(struct child_sync *sync)
{
 sem_destroy(&sync->sem_parent);
 sem_destroy(&sync->sem_child);
}

int wait_child(struct child_sync *sync)
{
 int ret;

 /* Wait until the child prods us. */
 ret = sem_wait(&sync->sem_parent);
 if (ret) {
  perror("Error waiting for child");
  return 1;
 }

 return sync->child_gave_up;
}

int prod_child(struct child_sync *sync)
{
 int ret;

 /* Unblock the child now. */
 ret = sem_post(&sync->sem_child);
 if (ret) {
  perror("Error prodding child");
  return 1;
 }

 return 0;
}

int wait_parent(struct child_sync *sync)
{
 int ret;

 /* Wait until the parent prods us. */
 ret = sem_wait(&sync->sem_child);
 if (ret) {
  perror("Error waiting for parent");
  return 1;
 }

 return sync->parent_gave_up;
}

int prod_parent(struct child_sync *sync)
{
 int ret;

 /* Unblock the parent now. */
 ret = sem_post(&sync->sem_parent);
 if (ret) {
  perror("Error prodding parent");
  return 1;
 }

 return 0;
}