usr/src/lib/udapl/udapl_tavor/include/dapl_osd.h

   1 /*
   2  * CDDL HEADER START
   3  *
   4  * The contents of this file are subject to the terms of the
   5  * Common Development and Distribution License (the "License").
   6  * You may not use this file except in compliance with the License.
   7  *
   8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
   9  * or http://www.opensolaris.org/os/licensing.
  10  * See the License for the specific language governing permissions
  11  * and limitations under the License.
  12  *
  13  * When distributing Covered Code, include this CDDL HEADER in each
  14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
  15  * If applicable, add the following below this CDDL HEADER, with the
  16  * fields enclosed by brackets "[]" replaced with your own identifying
  17  * information: Portions Copyright [yyyy] [name of copyright owner]
  18  *
  19  * CDDL HEADER END
  20  */
  21
  22 /*
  23  * Copyright (c) 2002-2003, Network Appliance, Inc. All rights reserved.
  24  */
  25
  26 /*
  27  * Copyright 2005 Sun Microsystems, Inc.  All rights reserved.
  28  * Use is subject to license terms.
  29  */
  30
  31 /*
  32  *
  33  * HEADER: dapl_osd.h
  34  *
  35  * PURPOSE: Operating System Dependent layer
  36  * Description:
  37  *      Provide OS dependent data structures & functions with
  38  *      a canonical DAPL interface. Designed to be portable
  39  *      and hide OS specific quirks of common functions.
  40  *
  41  * $Id: dapl_osd.h,v 1.38 2003/08/20 14:08:57 sjs2 Exp $
  42  */
  43
  44 #ifndef _DAPL_OSD_H_
  45 #define _DAPL_OSD_H_
  46
  47 #ifdef __cplusplus
  48 extern "C" {
  49 #endif
  50
  51 /*
  52  * <assert.h> keys off of NDEBUG
  53  */
  54 #ifdef  DAPL_DBG
  55 #undef  NDEBUG
  56 #else
  57 #define NDEBUG
  58 #endif
  59
  60 #include <dat/udat.h>
  61 #include <assert.h>
  62 #include <errno.h>
  63 #include <pthread.h>
  64 #include <semaphore.h>
  65 #include <stdio.h>
  66 #include <stdlib.h>
  67 #include <string.h>
  68 #include <stdarg.h>
  69 #include <time.h>
  70 #include <syslog.h>
  71 #include <netdb.h>
  72 #include <atomic.h>
  73 #include "dapl_debug.h"
  74
  75 /*
  76  * networking related headers
  77  */
  78 #include <unistd.h>
  79 #include <fcntl.h>
  80 #include <sys/types.h>
  81 #include <sys/socket.h>
  82 #include <ctype.h>
  83 #include <arpa/inet.h>
  84
  85 #ifndef _INLINE_
  86 #define _INLINE_
  87 #endif /* _INLINE_ */
  88
  89 /*
  90  * initialization function
  91  */
  92 void dapl_os_init(void);
  93
  94 #define dapl_os_panic(args)                     \
  95 {                                       \
  96         fprintf(stderr, "PANIC in %s:%i:\n", __FILE__, __LINE__); \
  97         fprintf(stderr, args);                  \
  98         exit(1);                                \
  99 }
 100
 101 int dapl_os_get_env_bool(
 102         char            *env_str);
 103
 104 int dapl_os_get_env_val(
 105         char            *env_str,
 106         int             def_val);
 107
 108 /*
 109  * Atomic operations
 110  */
 111 typedef volatile DAT_COUNT DAPL_ATOMIC;
 112
 113 /*
 114  * dapl_os_atomic_inc
 115  *
 116  * get the current value of '*v', and then increment it.
 117  *
 118  * This is equivalent to an IB atomic fetch and add of 1,
 119  * except that a DAT_COUNT might be 32 bits, rather than 64
 120  * and it occurs in local memory.
 121  *
 122  * void dapl_os_atomic_inc(INOUT        DAPL_ATOMIC *v)
 123  */
 124 #define dapl_os_atomic_inc(v)   atomic_add_32((uint32_t *)(v), 1)
 125
 126 /*
 127  * dapl_os_atomic_dec
 128  *
 129  * decrement the current value of '*v'. No return value is required.
 130  *
 131  * void dapl_os_atomic_dec(INOUT        DAPL_ATOMIC *v)
 132  */
 133 #define dapl_os_atomic_dec(v)   assert(*v != 0);                \
 134                                 atomic_add_32((uint32_t *)(v), -1)
 135
 136 /*
 137  * dapl_os_atomic_assign
 138  *
 139  * assign 'new_value' to '*v' if the current value
 140  * matches the provided 'match_value'.
 141  *
 142  * Make no assignment if there is no match.
 143  *
 144  * Return the current value in any case.
 145  *
 146  * This matches the IBTA atomic operation compare & swap
 147  * except that it is for local memory and a DAT_COUNT may
 148  * be only 32 bits, rather than 64.
 149  *
 150  * DAT_COUNT dapl_os_atomic_assign(INOUT DAPL_ATOMIC *v,
 151  *      IN DAT_COUNT match_value, IN DAT_COUNT new_value)
 152  */
 153 #define dapl_os_atomic_assign(v, match_value, new_value)                \
 154                 atomic_cas_32((uint32_t *)(v), (uint32_t)(match_value), \
 155                     (uint32_t)(new_value))
 156
 157 /*
 158  * Thread Functions
 159  */
 160 typedef pthread_t               DAPL_OS_THREAD;
 161
 162 DAT_RETURN
 163 dapl_os_thread_create(
 164         IN  void                        (*func) (void *),
 165         IN  void                        *data,
 166         OUT DAPL_OS_THREAD              *thread_id);
 167
 168
 169 /*
 170  * Lock Functions
 171  */
 172
 173 typedef pthread_mutex_t         DAPL_OS_LOCK;
 174
 175 /*
 176  * DAT_RETURN dapl_os_lock_init(IN DAPL_OS_LOCK *m)
 177  */
 178 #define dapl_os_lock_init(m)    (void)                                  \
 179                                 ((0 == pthread_mutex_init((m), NULL)) ? \
 180                                         DAT_SUCCESS :                   \
 181                                         (DAT_CLASS_ERROR | DAT_INTERNAL_ERROR))
 182
 183 /* DAT_RETURN dapl_os_lock(IN DAPL_OS_LOCK *m) */
 184 #define dapl_os_lock(m)         ((DAT_RETURN)(                          \
 185                                 (0 == pthread_mutex_lock((m))) ?        \
 186                                         DAT_SUCCESS :                   \
 187                                         (DAT_CLASS_ERROR | DAT_INTERNAL_ERROR)))
 188
 189 /* DAT_RETURN dapl_os_unlock(IN DAPL_OS_LOCK *m) */
 190 #define dapl_os_unlock(m)       ((DAT_RETURN)(                          \
 191                                 (0 == pthread_mutex_unlock((m))) ?      \
 192                                         DAT_SUCCESS :                   \
 193                                         (DAT_CLASS_ERROR | DAT_INTERNAL_ERROR)))
 194
 195 /* DAT_RETURN dapl_os_lock_destroy(IN DAPL_OS_LOCK *m) */
 196 #define dapl_os_lock_destroy(m) ((DAT_RETURN)(                          \
 197                                 (0 == pthread_mutex_destroy((m))) ?     \
 198                                         DAT_SUCCESS :                   \
 199                                         (DAT_CLASS_ERROR | DAT_INTERNAL_ERROR)))
 200 /*
 201  * Wait Objects
 202  */
 203
 204 /*
 205  * The wait object invariant: Presuming a call to dapl_os_wait_object_wait
 206  * occurs at some point, there will be at least one wakeup after each call
 207  * to dapl_os_wait_object_signal.  I.e. Signals are not ignored, though
 208  * they may be coallesced.
 209  */
 210
 211 typedef struct
 212 {
 213     DAT_BOOLEAN         signaled;
 214     pthread_cond_t      cv;
 215     pthread_mutex_t     lock;
 216 } DAPL_OS_WAIT_OBJECT;
 217
 218 /* function prototypes */
 219 DAT_RETURN
 220 dapl_os_wait_object_init(
 221     IN DAPL_OS_WAIT_OBJECT *wait_obj);
 222
 223 DAT_RETURN
 224 dapl_os_wait_object_wait(
 225     IN  DAPL_OS_WAIT_OBJECT *wait_obj,
 226     IN  DAT_TIMEOUT timeout_val);
 227
 228 DAT_RETURN
 229 dapl_os_wait_object_wakeup(
 230     IN  DAPL_OS_WAIT_OBJECT *wait_obj);
 231
 232 DAT_RETURN
 233 dapl_os_wait_object_destroy(
 234     IN  DAPL_OS_WAIT_OBJECT *wait_obj);
 235
 236 /*
 237  * Memory Functions
 238  */
 239
 240 /* void *dapl_os_alloc(int size) */
 241 #define dapl_os_alloc(size)     malloc((size))
 242
 243 /* void *dapl_os_realloc(void *ptr, int size) */
 244 #define dapl_os_realloc(ptr, size) realloc((ptr), (size))
 245
 246 /* void dapl_os_free(void *ptr, int size) */
 247 #define dapl_os_free(ptr, size) free((ptr))
 248
 249 /* void * dapl_os_memzero(void *loc, int size) */
 250 #define dapl_os_memzero(loc, size)      memset((loc), 0, (size))
 251
 252 /* void * dapl_os_memcpy(void *dest, const void *src, int len) */
 253 #define dapl_os_memcpy(dest, src, len)  memcpy((dest), (src), (len))
 254
 255 /* int dapl_os_memcmp(const void *mem1, const void *mem2, int len) */
 256 #define dapl_os_memcmp(mem1, mem2, len) memcmp((mem1), (mem2), (len))
 257
 258 /*
 259  * String Functions
 260  */
 261
 262 /* unsigned int dapl_os_strlen(const char *str) */
 263 #define dapl_os_strlen(str)     strlen((str))
 264 /* char * dapl_os_strdup(const char *str) */
 265 #define dapl_os_strdup(str)     strdup((str))
 266 /* char *strcpy(char *dest, char *src) */
 267 #define dapl_os_strcpy(dest, src)       strcpy((dest), (src))
 268 /* char *strncpy(char *s1, const char *s2, size_t n) */
 269 #define dapl_os_strncpy(dest, src, len) strncpy((dest), (src), (len))
 270 /* char *strcat(char *dest, char *src) */
 271 #define dapl_os_strcat(dest, src)       strcat((dest), (src))
 272
 273 /*
 274  * Timer Functions
 275  */
 276
 277 typedef DAT_UINT64              DAPL_OS_TIMEVAL;
 278
 279
 280 typedef unsigned long long int  DAPL_OS_TICKS;
 281
 282 /* function prototypes */
 283
 284 /*
 285  * Sleep for the number of micro seconds specified by the invoking
 286  * function
 287  *
 288  * void dapl_os_sleep_usec(int sleep_time)
 289  */
 290 #define dapl_os_sleep_usec(sleep_time)  {                               \
 291                 struct timespec sleep_spec;                             \
 292                 sleep_spec.tv_sec = (sleep_time) / 100000;              \
 293                 sleep_spec.tv_nsec = (sleep_time) % 100000 * 1000;      \
 294                 nanosleep(&sleep_spec, NULL);                           \
 295                 }
 296
 297 DAT_RETURN dapl_os_get_time(DAPL_OS_TIMEVAL *);
 298
 299 /*
 300  *
 301  * Name Service Helper functions
 302  *
 303  */
 304 #if defined(IBHOSTS_NAMING)
 305 #define dapls_osd_getaddrinfo(name, addr_ptr)           \
 306                                 getaddrinfo((name), NULL, NULL, (addr_ptr))
 307 #define dapls_osd_freeaddrinfo(addr) freeaddrinfo((addr))
 308
 309 #endif /* IBHOSTS_NAMING */
 310
 311 /*
 312  * *printf format helpers. We use the C string constant concatenation
 313  * ability to define 64 bit formats, which unfortunatly are non standard
 314  * in the C compiler world. E.g. %llx for gcc, %I64x for Windows
 315  */
 316 #define F64d   "%lld"
 317 #define F64u   "%llu"
 318 #define F64x   "%llx"
 319 #define F64X   "%llX"
 320
 321
 322 /*
 323  *  Conversion Functions
 324  */
 325
 326 /* long int dapl_os_strtol(const char *nptr, char **endptr, int base) */
 327 #define dapl_os_strtol(nptr, endptr, base)      strtol((nptr), (endptr), (base))
 328
 329 /*
 330  *  Helper Functions
 331  */
 332
 333
 334 #define dapl_os_assert(expression)      assert((expression))
 335 #define dapl_os_printf                  printf
 336 #define dapl_os_vprintf(fmt, args)      vprintf((fmt), (args))
 337 #define dapl_os_syslog(fmt, args)       vsyslog(LOG_USER | LOG_DEBUG,   \
 338                                                 (fmt), (args))
 339 #ifdef __cplusplus
 340 }
 341 #endif
 342
 343 #endif /* _DAPL_OSD_H_ */