tools/testing/selftests/powerpc/ptrace/child.h

   1 // SPDX-License-Identifier: GPL-2.0+
   2 /*
   3  * Helper functions to sync execution between parent and child processes.
   4  *
   5  * Copyright 2018, Thiago Jung Bauermann, IBM Corporation.
   6  */
   7 #include <stdio.h>
   8 #include <stdbool.h>
   9 #include <semaphore.h>
  10
  11 /*
  12  * Information in a shared memory location for synchronization between child and
  13  * parent.
  14  */
  15 struct child_sync {
  16         /* The parent waits on this semaphore. */
  17         sem_t sem_parent;
  18
  19         /* If true, the child should give up as well. */
  20         bool parent_gave_up;
  21
  22         /* The child waits on this semaphore. */
  23         sem_t sem_child;
  24
  25         /* If true, the parent should give up as well. */
  26         bool child_gave_up;
  27 };
  28
  29 #define CHILD_FAIL_IF(x, sync)                                          \
  30         do {                                                            \
  31                 if (x) {                                                \
  32                         fprintf(stderr,                                 \
  33                                 "[FAIL] Test FAILED on line %d\n", __LINE__); \
  34                         (sync)->child_gave_up = true;                   \
  35                         prod_parent(sync);                              \
  36                         return 1;                                       \
  37                 }                                                       \
  38         } while (0)
  39
  40 #define PARENT_FAIL_IF(x, sync)                                         \
  41         do {                                                            \
  42                 if (x) {                                                \
  43                         fprintf(stderr,                                 \
  44                                 "[FAIL] Test FAILED on line %d\n", __LINE__); \
  45                         (sync)->parent_gave_up = true;                  \
  46                         prod_child(sync);                               \
  47                         return 1;                                       \
  48                 }                                                       \
  49         } while (0)
  50
  51 #define PARENT_SKIP_IF_UNSUPPORTED(x, sync)                             \
  52         do {                                                            \
  53                 if ((x) == -1 && (errno == ENODEV || errno == EINVAL)) { \
  54                         (sync)->parent_gave_up = true;                  \
  55                         prod_child(sync);                               \
  56                         SKIP_IF(1);                                     \
  57                 }                                                       \
  58         } while (0)
  59
  60 int init_child_sync(struct child_sync *sync)
  61 {
  62         int ret;
  63
  64         ret = sem_init(&sync->sem_parent, 1, 0);
  65         if (ret) {
  66                 perror("Semaphore initialization failed");
  67                 return 1;
  68         }
  69
  70         ret = sem_init(&sync->sem_child, 1, 0);
  71         if (ret) {
  72                 perror("Semaphore initialization failed");
  73                 return 1;
  74         }
  75
  76         return 0;
  77 }
  78
  79 void destroy_child_sync(struct child_sync *sync)
  80 {
  81         sem_destroy(&sync->sem_parent);
  82         sem_destroy(&sync->sem_child);
  83 }
  84
  85 int wait_child(struct child_sync *sync)
  86 {
  87         int ret;
  88
  89         /* Wait until the child prods us. */
  90         ret = sem_wait(&sync->sem_parent);
  91         if (ret) {
  92                 perror("Error waiting for child");
  93                 return 1;
  94         }
  95
  96         return sync->child_gave_up;
  97 }
  98
  99 int prod_child(struct child_sync *sync)
 100 {
 101         int ret;
 102
 103         /* Unblock the child now. */
 104         ret = sem_post(&sync->sem_child);
 105         if (ret) {
 106                 perror("Error prodding child");
 107                 return 1;
 108         }
 109
 110         return 0;
 111 }
 112
 113 int wait_parent(struct child_sync *sync)
 114 {
 115         int ret;
 116
 117         /* Wait until the parent prods us. */
 118         ret = sem_wait(&sync->sem_child);
 119         if (ret) {
 120                 perror("Error waiting for parent");
 121                 return 1;
 122         }
 123
 124         return sync->parent_gave_up;
 125 }
 126
 127 int prod_parent(struct child_sync *sync)
 128 {
 129         int ret;
 130
 131         /* Unblock the parent now. */
 132         ret = sem_post(&sync->sem_parent);
 133         if (ret) {
 134                 perror("Error prodding parent");
 135                 return 1;
 136         }
 137
 138         return 0;
 139 }