// 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;
}