mutex/mut_stub.c

   1 /*-
   2  * See the file LICENSE for redistribution information.
   3  *
   4  * Copyright (c) 1996-2009 Oracle.  All rights reserved.
   5  *
   6  * $Id$
   7  */
   8
   9 #ifndef HAVE_MUTEX_SUPPORT
  10 #include "db_config.h"
  11
  12 #include "db_int.h"
  13 #include "dbinc/db_page.h"
  14 #include "dbinc/db_am.h"
  15
  16 /*
  17  * If the library wasn't compiled with mutex support, various routines
  18  * aren't available.  Stub them here, returning an appropriate error.
  19  */
  20 static int __db_nomutex __P((ENV *));
  21
  22 /*
  23  * __db_nomutex --
  24  *      Error when a Berkeley DB build doesn't include mutexes.
  25  */
  26 static int
  27 __db_nomutex(env)
  28         ENV *env;
  29 {
  30         __db_errx(env, "library build did not include support for mutexes");
  31         return (DB_OPNOTSUP);
  32 }
  33
  34 int
  35 __mutex_alloc_pp(dbenv, flags, indxp)
  36         DB_ENV *dbenv;
  37         u_int32_t flags;
  38         db_mutex_t *indxp;
  39 {
  40         COMPQUIET(flags, 0);
  41         COMPQUIET(indxp, NULL);
  42         return (__db_nomutex(dbenv->env));
  43 }
  44
  45 int
  46 __mutex_alloc(env, alloc_id, flags, indxp)
  47         ENV *env;
  48         int alloc_id;
  49         u_int32_t flags;
  50         db_mutex_t *indxp;
  51 {
  52         COMPQUIET(env, NULL);
  53         COMPQUIET(alloc_id, 0);
  54         COMPQUIET(flags, 0);
  55         *indxp = MUTEX_INVALID;
  56         return (0);
  57 }
  58
  59 void
  60 __mutex_clear(env, mutex)
  61         ENV *env;
  62         db_mutex_t mutex;
  63 {
  64         COMPQUIET(env, NULL);
  65         COMPQUIET(mutex, MUTEX_INVALID);
  66 }
  67
  68 int
  69 __mutex_free_pp(dbenv, indx)
  70         DB_ENV *dbenv;
  71         db_mutex_t indx;
  72 {
  73         COMPQUIET(indx, 0);
  74         return (__db_nomutex(dbenv->env));
  75 }
  76
  77 int
  78 __mutex_free(env, indxp)
  79         ENV *env;
  80         db_mutex_t *indxp;
  81 {
  82         COMPQUIET(env, NULL);
  83         *indxp = MUTEX_INVALID;
  84         return (0);
  85 }
  86
  87 int
  88 __mutex_get_align(dbenv, alignp)
  89         DB_ENV *dbenv;
  90         u_int32_t *alignp;
  91 {
  92         COMPQUIET(alignp, NULL);
  93         return (__db_nomutex(dbenv->env));
  94 }
  95
  96 int
  97 __mutex_get_increment(dbenv, incrementp)
  98         DB_ENV *dbenv;
  99         u_int32_t *incrementp;
 100 {
 101         COMPQUIET(incrementp, NULL);
 102         return (__db_nomutex(dbenv->env));
 103 }
 104
 105 int
 106 __mutex_get_max(dbenv, maxp)
 107         DB_ENV *dbenv;
 108         u_int32_t *maxp;
 109 {
 110         COMPQUIET(maxp, NULL);
 111         return (__db_nomutex(dbenv->env));
 112 }
 113
 114 int
 115 __mutex_get_tas_spins(dbenv, tas_spinsp)
 116         DB_ENV *dbenv;
 117         u_int32_t *tas_spinsp;
 118 {
 119         COMPQUIET(tas_spinsp, NULL);
 120         return (__db_nomutex(dbenv->env));
 121 }
 122
 123 int
 124 __mutex_lock_pp(dbenv, indx)
 125         DB_ENV *dbenv;
 126         db_mutex_t indx;
 127 {
 128         COMPQUIET(indx, 0);
 129         return (__db_nomutex(dbenv->env));
 130 }
 131
 132 void
 133 __mutex_print_debug_single(env, tag, mutex, flags)
 134         ENV *env;
 135         const char *tag;
 136         db_mutex_t mutex;
 137         u_int32_t flags;
 138 {
 139         COMPQUIET(env, NULL);
 140         COMPQUIET(tag, NULL);
 141         COMPQUIET(mutex, MUTEX_INVALID);
 142         COMPQUIET(flags, 0);
 143 }
 144
 145 void
 146 __mutex_print_debug_stats(env, mbp, mutex, flags)
 147         ENV *env;
 148         DB_MSGBUF *mbp;
 149         db_mutex_t mutex;
 150         u_int32_t flags;
 151 {
 152         COMPQUIET(env, NULL);
 153         COMPQUIET(mbp, NULL);
 154         COMPQUIET(mutex, MUTEX_INVALID);
 155         COMPQUIET(flags, 0);
 156 }
 157
 158 int
 159 __mutex_set_align(dbenv, align)
 160         DB_ENV *dbenv;
 161         u_int32_t align;
 162 {
 163         COMPQUIET(align, 0);
 164         return (__db_nomutex(dbenv->env));
 165 }
 166
 167 int
 168 __mutex_set_increment(dbenv, increment)
 169         DB_ENV *dbenv;
 170         u_int32_t increment;
 171 {
 172         COMPQUIET(increment, 0);
 173         return (__db_nomutex(dbenv->env));
 174 }
 175
 176 int
 177 __mutex_set_max(dbenv, max)
 178         DB_ENV *dbenv;
 179         u_int32_t max;
 180 {
 181         COMPQUIET(max, 0);
 182         return (__db_nomutex(dbenv->env));
 183 }
 184
 185 int
 186 __mutex_set_tas_spins(dbenv, tas_spins)
 187         DB_ENV *dbenv;
 188         u_int32_t tas_spins;
 189 {
 190         COMPQUIET(tas_spins, 0);
 191         return (__db_nomutex(dbenv->env));
 192 }
 193
 194 void
 195 __mutex_set_wait_info(env, mutex, waitp, nowaitp)
 196         ENV *env;
 197         db_mutex_t mutex;
 198         uintmax_t *waitp, *nowaitp;
 199 {
 200         COMPQUIET(env, NULL);
 201         COMPQUIET(mutex, MUTEX_INVALID);
 202         *waitp = *nowaitp = 0;
 203 }
 204
 205 int
 206 __mutex_stat_pp(dbenv, statp, flags)
 207         DB_ENV *dbenv;
 208         DB_MUTEX_STAT **statp;
 209         u_int32_t flags;
 210 {
 211         COMPQUIET(statp, NULL);
 212         COMPQUIET(flags, 0);
 213         return (__db_nomutex(dbenv->env));
 214 }
 215
 216 int
 217 __mutex_stat_print_pp(dbenv, flags)
 218         DB_ENV *dbenv;
 219         u_int32_t flags;
 220 {
 221         COMPQUIET(flags, 0);
 222         return (__db_nomutex(dbenv->env));
 223 }
 224
 225 int
 226 __mutex_unlock_pp(dbenv, indx)
 227         DB_ENV *dbenv;
 228         db_mutex_t indx;
 229 {
 230         COMPQUIET(indx, 0);
 231         return (__db_nomutex(dbenv->env));
 232 }
 233 #endif /* !HAVE_MUTEX_SUPPORT */