src/rx/IRIX/rx_kmutex.h

   1 /*
   2  * Copyright 2000, International Business Machines Corporation and others.
   3  * All Rights Reserved.
   4  *
   5  * This software has been released under the terms of the IBM Public
   6  * License.  For details, see the LICENSE file in the top-level source
   7  * directory or online at http://www.openafs.org/dl/license10.html
   8  */
   9
  10 /*
  11  * rx_kmutex.h - mutex and condition variable macros for kernel environment.
  12  *
  13  * IRIX implementation.
  14  */
  15
  16 #ifndef _RX_KMUTEX_H_
  17 #define _RX_KMUTEX_H_
  18
  19 #ifdef AFS_SGI62_ENV
  20
  21 #ifdef MP
  22 #define RX_ENABLE_LOCKS 1
  23 #define AFS_GLOBAL_RXLOCK_KERNEL 1
  24
  25
  26 #include "sys/sema.h"
  27 #ifndef mutex_tryenter
  28 #define mutex_tryenter(m) cpsema(m)
  29 #endif /* mutex_tryenter */
  30 typedef kmutex_t afs_kmutex_t;
  31 typedef afs_kmutex_t afs_krwlock_t;
  32 typedef kcondvar_t afs_kcondvar_t;
  33
  34 #ifndef CV_DEFAULT
  35 #define CV_DEFAULT      0
  36 #endif
  37 #ifndef MUTEX_DEFAULT
  38 #define MUTEX_DEFAULT   0
  39 #endif
  40
  41 #define RWLOCK_INIT(a, b, c, d) MUTEX_INIT(a,b,c,d)
  42 #define RWLOCK_DESTROY(l)       MUTEX_DESTROY(l)
  43 #define RWLOCK_UPLOCK(l)
  44 #define RWLOCK_WRLOCK(l)        MUTEX_ENTER(l)
  45 #define RWLOCK_RDLOCK(l)        MUTEX_ENTER(l)
  46 #define RWLOCK_TRYWRLOCK(l)     MUTEX_TRYENTER(l)
  47 #define RWLOCK_TRYRDLOCK(l)     MUTEX_TRYENTER(l)
  48 #define RWLOCK_UNLOCK(l)        MUTEX_EXIT(l)
  49
  50 #ifdef AFS_SGI62_ENV
  51 #define MUTEX_INIT(m, nm, type , a)  mutex_init(m, type, nm)
  52 #else
  53 #define MUTEX_INIT(a,b,c,d)  mutex_init(a,b,c,d)
  54 #endif
  55 #define MUTEX_DESTROY(a) mutex_destroy(a)
  56 #undef MUTEX_ISMINE
  57 #define MUTEX_ISMINE(a) 1
  58 #define CV_INIT(cv, a,b,c)      cv_init(cv, a, b, c)
  59 #define CV_SIGNAL(_cv)          cv_signal(_cv)
  60 #define CV_BROADCAST(_cv)       cv_broadcast(_cv)
  61 #define CV_DESTROY(_cv)         cv_destroy(_cv)
  62 #undef osirx_AssertMine
  63 extern void osirx_AssertMine(afs_kmutex_t * lockaddr, char *msg);
  64 #ifdef AFS_SGI64_ENV
  65 /* Add PLTWAIT for afsd's to wait so we don't rack up the load average. */
  66 #ifdef AFS_SGI65_ENV
  67 #define AFSD_PRI() ((kt_basepri(curthreadp) == PTIME_SHARE) ? PZERO : (PZERO|PLTWAIT))
  68 #else
  69 #define AFSD_PRI() ((curprocp && curprocp->p_rss==0) ? (PZERO|PLTWAIT) : PZERO)
  70 #endif /* SGI65 */
  71 #undef cv_wait
  72 #define cv_wait(cv, mp) { \
  73         sv_wait(cv, AFSD_PRI(), mp, 0); \
  74         AFS_MUTEX_ENTER(mp); \
  75 }
  76 #endif /* AFS_SGI64_ENV */
  77 #ifdef RX_LOCKS_DB
  78 #define MUTEX_ENTER(a)          do { \
  79                                      AFS_MUTEX_ENTER(a); \
  80                                      rxdb_grablock((a), osi_ThreadUnique(), \
  81                                                    rxdb_fileID, __LINE__); \
  82                                  } while(0)
  83 #define MUTEX_TRYENTER(a)       (mutex_tryenter(a) ? \
  84                                      (rxdb_grablock((a), osi_ThreadUnique(), \
  85                                                    rxdb_fileID, __LINE__), 1) \
  86                                                    : 0)
  87 #define MUTEX_EXIT(a)           do { \
  88                                      rxdb_droplock((a), osi_ThreadUnique(), \
  89                                                    rxdb_fileID, __LINE__); \
  90                                      mutex_exit(a); \
  91                                  } while(0)
  92 #define CV_WAIT(_cv, _lck)      do { \
  93                                      int haveGlock = ISAFS_GLOCK(); \
  94                                      if (haveGlock) \
  95                                         AFS_GUNLOCK(); \
  96                                      rxdb_droplock((_lck), \
  97                                                    osi_ThreadUnique(), \
  98                                                    rxdb_fileID, __LINE__); \
  99                                      cv_wait(_cv, _lck); \
 100                                      rxdb_grablock((_lck), \
 101                                                    osi_ThreadUnique(), \
 102                                                    rxdb_fileID, __LINE__); \
 103                                      if (haveGlock) { \
 104                                         MUTEX_EXIT(_lck); \
 105                                         AFS_GLOCK(); \
 106                                         MUTEX_ENTER(_lck); \
 107                                      } \
 108                                  } while (0)
 109 #define CV_TIMEDWAIT(_cv,_lck,_t)       do { \
 110                                      int haveGlock = ISAFS_GLOCK(); \
 111                                      if (haveGlock) \
 112                                         AFS_GUNLOCK(); \
 113                                      rxdb_droplock((_lck), \
 114                                                    osi_ThreadUnique(), \
 115                                                    rxdb_fileID, __LINE__); \
 116                                      cv_timedwait(_cv, _lck, t); \
 117                                      rxdb_grablock((_lck), \
 118                                                    osi_ThreadUnique(), \
 119                                                    rxdb_fileID, __LINE__); \
 120                                      if (haveGlock) { \
 121                                         MUTEX_EXIT(_lck); \
 122                                         AFS_GLOCK(); \
 123                                         MUTEX_ENTER(_lck); \
 124                                      } \
 125                                  } while (0)
 126 #else /* RX_LOCKS_DB */
 127 #define MUTEX_ENTER(a) AFS_MUTEX_ENTER(a)
 128 #define MUTEX_TRYENTER(a) mutex_tryenter(a)
 129 #define MUTEX_EXIT(a)  mutex_exit(a)
 130 #define CV_WAIT(_cv, _lck)      do { \
 131                                         int haveGlock = ISAFS_GLOCK(); \
 132                                         if (haveGlock) \
 133                                             AFS_GUNLOCK(); \
 134                                         cv_wait(_cv, _lck); \
 135                                         if (haveGlock) { \
 136                                             MUTEX_EXIT(_lck); \
 137                                             AFS_GLOCK(); \
 138                                             MUTEX_ENTER(_lck); \
 139                                         } \
 140                                     } while (0)
 141 #define CV_TIMEDWAIT(cv,lck,t)  do { \
 142                                         int haveGlock = ISAFS_GLOCK(); \
 143                                         if (haveGlock) \
 144                                             AFS_GUNLOCK(); \
 145                                         cv_timedwait(_cv, _lck, t); \
 146                                         if (haveGlock) { \
 147                                             MUTEX_EXIT(_lck); \
 148                                             AFS_GLOCK(); \
 149                                             MUTEX_ENTER(_lck); \
 150                                         } \
 151                                     } while (0)
 152 #endif /* RX_LOCKS_DB */
 153
 154
 155 #else /* MP */
 156 #define MUTEX_INIT(m, nm, type , a)
 157 #define MUTEX_DESTROY(a)
 158 #define MUTEX_ISMINE(a) 1
 159 #define MUTEX_ENTER(a)
 160 #define MUTEX_TRYENTER(a) 1
 161 #define MUTEX_EXIT(a)
 162
 163 #define osirx_AssertMine(addr, msg)
 164
 165 #define CV_INIT(cv, a,b,c)
 166 #define CV_SIGNAL(_cv)
 167 #define CV_BROADCAST(_cv)
 168 #define CV_DESTROY(_cv)
 169 #define CV_WAIT(_cv, _lck)
 170 #define CV_TIMEDWAIT(cv,lck,t)
 171
 172 #endif /* MP */
 173
 174 #endif /* SGI62 */
 175
 176 #endif /* _RX_KMUTEX_H_ */