release/src/router/mysql/storage/ndb/include/kernel/signaldata/UtilLock.hpp

   1 /* Copyright (c) 2003-2005 MySQL AB
   2
   3    This program is free software; you can redistribute it and/or modify
   4    it under the terms of the GNU General Public License as published by
   5    the Free Software Foundation; version 2 of the License.
   6
   7    This program is distributed in the hope that it will be useful,
   8    but WITHOUT ANY WARRANTY; without even the implied warranty of
   9    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  10    GNU General Public License for more details.
  11
  12    You should have received a copy of the GNU General Public License
  13    along with this program; if not, write to the Free Software
  14    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA */
  15
  16 #ifndef UTIL_LOCK_HPP
  17 #define UTIL_LOCK_HPP
  18
  19 #include "SignalData.hpp"
  20
  21 class UtilLockReq {
  22
  23   /**
  24    * Receiver
  25    */
  26   friend class DbUtil;
  27
  28   /**
  29    * Sender
  30    */
  31   friend class Dbdih;
  32   friend class MutexManager;
  33
  34   friend bool printUTIL_LOCK_REQ(FILE *, const Uint32 *, Uint32, Uint16);
  35 public:
  36   STATIC_CONST( SignalLength = 4 );
  37
  38   enum RequestInfo {
  39     TryLock = 1
  40   };
  41 public:
  42   Uint32 senderData;
  43   Uint32 senderRef;
  44   Uint32 lockId;
  45   Uint32 requestInfo;
  46 };
  47
  48 class UtilLockConf {
  49
  50   /**
  51    * Receiver
  52    */
  53   friend class Dbdih;
  54   friend class MutexManager;
  55
  56   /**
  57    * Sender
  58    */
  59   friend class DbUtil;
  60
  61   friend bool printUTIL_LOCK_CONF(FILE *, const Uint32 *, Uint32, Uint16);
  62 public:
  63   STATIC_CONST( SignalLength = 4 );
  64
  65 public:
  66   Uint32 senderData;
  67   Uint32 senderRef;
  68   Uint32 lockId;
  69   Uint32 lockKey;
  70 };
  71
  72 class UtilLockRef {
  73
  74   /**
  75    * Reciver
  76    */
  77   friend class Dbdih;
  78   friend class MutexManager;
  79
  80   /**
  81    * Sender
  82    */
  83   friend class DbUtil;
  84
  85   friend bool printUTIL_LOCK_REF(FILE *, const Uint32 *, Uint32, Uint16);
  86 public:
  87   STATIC_CONST( SignalLength = 4 );
  88
  89   enum ErrorCode {
  90     OK = 0,
  91     NoSuchLock = 1,
  92     OutOfLockRecords = 2,
  93     DistributedLockNotSupported = 3,
  94     LockAlreadyHeld = 4
  95
  96   };
  97 public:
  98   Uint32 senderData;
  99   Uint32 senderRef;
 100   Uint32 lockId;
 101   Uint32 errorCode;
 102 };
 103
 104 class UtilUnlockReq {
 105
 106   /**
 107    * Receiver
 108    */
 109   friend class DbUtil;
 110
 111   /**
 112    * Sender
 113    */
 114   friend class Dbdih;
 115   friend class MutexManager;
 116
 117   friend bool printUTIL_UNLOCK_REQ(FILE *, const Uint32 *, Uint32, Uint16);
 118 public:
 119   STATIC_CONST( SignalLength = 4 );
 120
 121 public:
 122   Uint32 senderData;
 123   Uint32 senderRef;
 124   Uint32 lockId;
 125   Uint32 lockKey;
 126 };
 127
 128 class UtilUnlockConf {
 129
 130   /**
 131    * Receiver
 132    */
 133   friend class Dbdih;
 134   friend class MutexManager;
 135
 136   /**
 137    * Sender
 138    */
 139   friend class DbUtil;
 140
 141   friend bool printUTIL_UNLOCK_CONF(FILE *, const Uint32 *, Uint32, Uint16);
 142 public:
 143   STATIC_CONST( SignalLength = 3 );
 144
 145 public:
 146   Uint32 senderData;
 147   Uint32 senderRef;
 148   Uint32 lockId;
 149 };
 150
 151 class UtilUnlockRef {
 152
 153   /**
 154    * Reciver
 155    */
 156   friend class Dbdih;
 157   friend class MutexManager;
 158
 159   /**
 160    * Sender
 161    */
 162   friend class DbUtil;
 163
 164   friend bool printUTIL_UNLOCK_REF(FILE *, const Uint32 *, Uint32, Uint16);
 165 public:
 166   STATIC_CONST( SignalLength = 4 );
 167
 168   enum ErrorCode {
 169     OK = 0,
 170     NoSuchLock = 1,
 171     NotLockOwner = 2
 172   };
 173 public:
 174   Uint32 senderData;
 175   Uint32 senderRef;
 176   Uint32 lockId;
 177   Uint32 errorCode;
 178 };
 179
 180 /**
 181  * Creating a lock
 182  */
 183 class UtilCreateLockReq {
 184   /**
 185    * Receiver
 186    */
 187   friend class DbUtil;
 188
 189   /**
 190    * Sender
 191    */
 192   friend class MutexManager;
 193
 194   friend bool printUTIL_CREATE_LOCK_REQ(FILE *, const Uint32*, Uint32, Uint16);
 195 public:
 196   enum LockType {
 197     Mutex = 0 // Lock with only exclusive locks
 198   };
 199
 200   STATIC_CONST( SignalLength = 4 );
 201
 202 public:
 203   Uint32 senderData;
 204   Uint32 senderRef;
 205   Uint32 lockId;
 206   Uint32 lockType;
 207 };
 208
 209 class UtilCreateLockRef {
 210   /**
 211    * Sender
 212    */
 213   friend class DbUtil;
 214
 215   /**
 216    * Receiver
 217    */
 218   friend class MutexManager;
 219
 220   friend bool printUTIL_CREATE_LOCK_REF(FILE *, const Uint32*, Uint32, Uint16);
 221 public:
 222   enum ErrorCode {
 223     OK = 0,
 224     OutOfLockQueueRecords = 1,
 225     LockIdAlreadyUsed = 2,
 226     UnsupportedLockType = 3
 227   };
 228
 229   STATIC_CONST( SignalLength = 4 );
 230
 231 public:
 232   Uint32 senderData;
 233   Uint32 senderRef;
 234   Uint32 lockId;
 235   Uint32 errorCode;
 236 };
 237
 238 class UtilCreateLockConf {
 239   /**
 240    * Sender
 241    */
 242   friend class DbUtil;
 243
 244   /**
 245    * Receiver
 246    */
 247   friend class MutexManager;
 248
 249   friend bool printUTIL_CREATE_LOCK_CONF(FILE*, const Uint32*, Uint32, Uint16);
 250 public:
 251   STATIC_CONST( SignalLength = 3 );
 252
 253 public:
 254   Uint32 senderData;
 255   Uint32 senderRef;
 256   Uint32 lockId;
 257 };
 258
 259 /**
 260  * Creating a lock
 261  */
 262 class UtilDestroyLockReq {
 263   /**
 264    * Receiver
 265    */
 266   friend class DbUtil;
 267
 268   /**
 269    * Sender
 270    */
 271   friend class MutexManager;
 272
 273   friend bool printUTIL_DESTROY_LOCK_REQ(FILE *, const Uint32*, Uint32, Uint16);
 274 public:
 275   STATIC_CONST( SignalLength = 4 );
 276
 277 public:
 278   Uint32 senderData;
 279   Uint32 senderRef;
 280   Uint32 lockId;
 281   Uint32 lockKey;
 282 };
 283
 284 class UtilDestroyLockRef {
 285   /**
 286    * Sender
 287    */
 288   friend class DbUtil;
 289
 290   /**
 291    * Receiver
 292    */
 293   friend class MutexManager;
 294
 295   friend bool printUTIL_DESTROY_LOCK_REF(FILE *, const Uint32*, Uint32, Uint16);
 296 public:
 297   enum ErrorCode {
 298     OK = 0,
 299     NoSuchLock = 1,
 300     NotLockOwner = 2
 301   };
 302
 303   STATIC_CONST( SignalLength = 4 );
 304
 305 public:
 306   Uint32 senderData;
 307   Uint32 senderRef;
 308   Uint32 lockId;
 309   Uint32 errorCode;
 310 };
 311
 312 class UtilDestroyLockConf {
 313   /**
 314    * Sender
 315    */
 316   friend class DbUtil;
 317
 318   /**
 319    * Receiver
 320    */
 321   friend class MutexManager;
 322
 323   friend bool printUTIL_DESTROY_LOCK_CONF(FILE*, const Uint32*, Uint32, Uint16);
 324 public:
 325   STATIC_CONST( SignalLength = 3 );
 326
 327 public:
 328   Uint32 senderData;
 329   Uint32 senderRef;
 330   Uint32 lockId;
 331 };
 332
 333 #endif