contrib/processor-trace/include/posix/threads.h

   1 /*
   2  * Copyright (c) 2014-2018, Intel Corporation
   3  *
   4  * Redistribution and use in source and binary forms, with or without
   5  * modification, are permitted provided that the following conditions are met:
   6  *
   7  *  * Redistributions of source code must retain the above copyright notice,
   8  *    this list of conditions and the following disclaimer.
   9  *  * Redistributions in binary form must reproduce the above copyright notice,
  10  *    this list of conditions and the following disclaimer in the documentation
  11  *    and/or other materials provided with the distribution.
  12  *  * Neither the name of Intel Corporation nor the names of its contributors
  13  *    may be used to endorse or promote products derived from this software
  14  *    without specific prior written permission.
  15  *
  16  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
  17  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  18  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  19  * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
  20  * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  21  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  22  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  23  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  24  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  25  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  26  * POSSIBILITY OF SUCH DAMAGE.
  27  *
  28  *
  29  * It looks like there is still no support for C11's threads.h.
  30  *
  31  * We implement the few features we actually need hoping that this file will
  32  * soon go away.
  33  */
  34
  35 #ifndef THREADS_H
  36 #define THREADS_H
  37
  38 #include <pthread.h>
  39
  40 #ifndef PTHREAD_MUTEX_NORMAL
  41 #  define PTHREAD_MUTEX_NORMAL PTHREAD_MUTEX_TIMED_NP
  42 #endif
  43
  44 #include <stdint.h>
  45 #include <stdlib.h>
  46
  47 enum {
  48         thrd_success    = 1,
  49         thrd_error
  50 };
  51
  52 struct pt_thread {
  53         pthread_t thread;
  54 };
  55 typedef struct pt_thread thrd_t;
  56
  57 typedef int (*thrd_start_t)(void *);
  58
  59
  60 struct thrd_args {
  61         thrd_start_t fun;
  62         void *arg;
  63 };
  64
  65 static void *thrd_routine(void *arg)
  66 {
  67         struct thrd_args *args;
  68         int result;
  69
  70         args = arg;
  71         if (!args)
  72                 return (void *) (intptr_t) -1;
  73
  74         result = -1;
  75         if (args->fun)
  76                 result = args->fun(args->arg);
  77
  78         free(args);
  79
  80         return (void *) (intptr_t) result;
  81 }
  82
  83 static inline int thrd_create(thrd_t *thrd, thrd_start_t fun, void *arg)
  84 {
  85         struct thrd_args *args;
  86         int errcode;
  87
  88         if (!thrd || !fun)
  89                 return thrd_error;
  90
  91         args = malloc(sizeof(*args));
  92         if (!args)
  93                 return thrd_error;
  94
  95         args->fun = fun;
  96         args->arg = arg;
  97
  98         errcode = pthread_create(&thrd->thread, NULL, thrd_routine, args);
  99         if (errcode) {
 100                 free(args);
 101                 return thrd_error;
 102         }
 103
 104         return thrd_success;
 105 }
 106
 107 static inline int thrd_join(thrd_t *thrd, int *res)
 108 {
 109         void *result;
 110         int errcode;
 111
 112         if (!thrd)
 113                 return thrd_error;
 114
 115         errcode = pthread_join(thrd->thread, &result);
 116         if (errcode)
 117                 return thrd_error;
 118
 119         if (res)
 120                 *res = (int) (intptr_t) result;
 121
 122         return thrd_success;
 123 }
 124
 125
 126 struct pt_mutex {
 127         pthread_mutex_t mutex;
 128 };
 129 typedef struct pt_mutex mtx_t;
 130
 131 enum {
 132         mtx_plain = PTHREAD_MUTEX_NORMAL
 133 };
 134
 135 static inline int mtx_init(mtx_t *mtx, int type)
 136 {
 137         int errcode;
 138
 139         if (!mtx || type != mtx_plain)
 140                 return thrd_error;
 141
 142         errcode = pthread_mutex_init(&mtx->mutex, NULL);
 143         if (errcode)
 144                 return thrd_error;
 145
 146         return thrd_success;
 147 }
 148
 149 static inline void mtx_destroy(mtx_t *mtx)
 150 {
 151         if (mtx)
 152                 (void) pthread_mutex_destroy(&mtx->mutex);
 153 }
 154
 155 static inline int mtx_lock(mtx_t *mtx)
 156 {
 157         int errcode;
 158
 159         if (!mtx)
 160                 return thrd_error;
 161
 162         errcode = pthread_mutex_lock(&mtx->mutex);
 163         if (errcode)
 164                 return thrd_error;
 165
 166         return thrd_success;
 167 }
 168
 169 static inline int mtx_unlock(mtx_t *mtx)
 170 {
 171         int errcode;
 172
 173         if (!mtx)
 174                 return thrd_error;
 175
 176         errcode = pthread_mutex_unlock(&mtx->mutex);
 177         if (errcode)
 178                 return thrd_error;
 179
 180         return thrd_success;
 181 }
 182
 183
 184 struct pt_cond {
 185         pthread_cond_t cond;
 186 };
 187 typedef struct pt_cond cnd_t;
 188
 189 static inline int cnd_init(cnd_t *cnd)
 190 {
 191         int errcode;
 192
 193         if (!cnd)
 194                 return thrd_error;
 195
 196         errcode = pthread_cond_init(&cnd->cond, NULL);
 197         if (errcode)
 198                 return thrd_error;
 199
 200         return thrd_success;
 201 }
 202
 203 static inline int cnd_destroy(cnd_t *cnd)
 204 {
 205         int errcode;
 206
 207         if (!cnd)
 208                 return thrd_error;
 209
 210         errcode = pthread_cond_destroy(&cnd->cond);
 211         if (errcode)
 212                 return thrd_error;
 213
 214         return thrd_success;
 215 }
 216
 217 static inline int cnd_signal(cnd_t *cnd)
 218 {
 219         int errcode;
 220
 221         if (!cnd)
 222                 return thrd_error;
 223
 224         errcode = pthread_cond_signal(&cnd->cond);
 225         if (errcode)
 226                 return thrd_error;
 227
 228         return thrd_success;
 229 }
 230
 231 static inline int cnd_broadcast(cnd_t *cnd)
 232 {
 233         int errcode;
 234
 235         if (!cnd)
 236                 return thrd_error;
 237
 238         errcode = pthread_cond_broadcast(&cnd->cond);
 239         if (errcode)
 240                 return thrd_error;
 241
 242         return thrd_success;
 243 }
 244
 245 static inline int cnd_wait(cnd_t *cnd, mtx_t *mtx)
 246 {
 247         int errcode;
 248
 249         if (!cnd || !mtx)
 250                 return thrd_error;
 251
 252         errcode = pthread_cond_wait(&cnd->cond, &mtx->mutex);
 253         if (errcode)
 254                 return thrd_error;
 255
 256         return thrd_success;
 257 }
 258
 259 #endif /* THREADS_H */