开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 数据库系统 > MySQL数据库 > 查看源码
Mutex.cpp
资源名称：mysql-4.1.16-win-src.zip　[点击查看]
上传用户：romrleung
上传日期：2022-05-23
资源大小：18897k
文件大小：8k
源码类别：

MySQL数据库

开发平台：

Visual C++

Mutex.cpp：源码内容
  1. /* Copyright (C) 2003 MySQL AB
  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; either version 2 of the License, or
  6.    (at your option) any later version.
  8.    This program is distributed in the hope that it will be useful,
  9.    but WITHOUT ANY WARRANTY; without even the implied warranty of
  10.    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  11.    GNU General Public License for more details.
  13.    You should have received a copy of the GNU General Public License
  14.    along with this program; if not, write to the Free Software
  15.    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
  18. #include "SimulatedBlock.hpp"
  19. #include "Mutex.hpp"
  20. #include <signaldata/UtilLock.hpp>
  22. SimulatedBlock::MutexManager::MutexManager(class SimulatedBlock & block) 
  23.   : m_block(block),
  24.     m_activeMutexes(m_mutexPool) {
  25. }
  26.   
  27. bool
  28. SimulatedBlock::MutexManager::setSize(Uint32 maxNoOfActiveMutexes){
  29.   return m_mutexPool.setSize(maxNoOfActiveMutexes);
  30. }
  32. Uint32
  33. SimulatedBlock::MutexManager::getSize() const {
  34.   return m_mutexPool.getSize();
  35. }
  37. bool
  38. SimulatedBlock::MutexManager::seize(ActiveMutexPtr& ptr){
  39.   return m_activeMutexes.seize(ptr);
  40. }
  42. void
  43. SimulatedBlock::MutexManager::release(Uint32 activeMutexPtrI){
  44.   m_activeMutexes.release(activeMutexPtrI);
  45. }
  47. void
  48. SimulatedBlock::MutexManager::getPtr(ActiveMutexPtr& ptr){
  49.   m_activeMutexes.getPtr(ptr);
  50. }
  52. BlockReference
  53. SimulatedBlock::MutexManager::reference() const { 
  54.   return m_block.reference(); 
  55. }
  57. void
  58. SimulatedBlock::MutexManager::progError(int line, 
  59. int err_code, 
  60. const char* extra)
  61. {
  62.   m_block.progError(line, err_code, extra); 
  63. }
  65. void
  66. SimulatedBlock::MutexManager::create(Signal* signal, ActiveMutexPtr& ptr){
  67.   
  68.   UtilCreateLockReq * req = (UtilCreateLockReq*)signal->getDataPtrSend();
  69.   req->senderData = ptr.i;
  70.   req->senderRef = m_block.reference();
  71.   req->lockId = ptr.p->m_mutexId;
  72.   req->lockType = UtilCreateLockReq::Mutex;
  74.   m_block.sendSignal(DBUTIL_REF, 
  75.      GSN_UTIL_CREATE_LOCK_REQ, 
  76.      signal,
  77.      UtilCreateLockReq::SignalLength,
  78.      JBB);
  80.   ptr.p->m_gsn = GSN_UTIL_CREATE_LOCK_REQ;
  81. }
  83. void
  84. SimulatedBlock::MutexManager::execUTIL_CREATE_LOCK_REF(Signal* signal){
  86.   UtilCreateLockRef * ref = (UtilCreateLockRef*)signal->getDataPtr();
  87.   ActiveMutexPtr ptr;
  88.   m_activeMutexes.getPtr(ptr, ref->senderData);
  89.   ndbrequire(ptr.p->m_gsn == GSN_UTIL_CREATE_LOCK_REQ);
  90.   ndbrequire(ptr.p->m_mutexId == ref->lockId);
  92.   ptr.p->m_gsn = 0;
  93.   m_block.execute(signal, ptr.p->m_callback, ref->errorCode);
  94. }
  96. void 
  97. SimulatedBlock::MutexManager::execUTIL_CREATE_LOCK_CONF(Signal* signal){
  99.   UtilCreateLockConf * conf = (UtilCreateLockConf*)signal->getDataPtr();
  100.   ActiveMutexPtr ptr;
  101.   m_activeMutexes.getPtr(ptr, conf->senderData);
  102.   ndbrequire(ptr.p->m_gsn == GSN_UTIL_CREATE_LOCK_REQ);
  103.   ndbrequire(ptr.p->m_mutexId == conf->lockId);
  105.   ptr.p->m_gsn = 0;
  106.   m_block.execute(signal, ptr.p->m_callback, 0);
  107. }
  110. void
  111. SimulatedBlock::MutexManager::destroy(Signal* signal, ActiveMutexPtr& ptr){
  113.   UtilDestroyLockReq * req = (UtilDestroyLockReq*)signal->getDataPtrSend();
  114.   req->senderData = ptr.i;
  115.   req->senderRef = m_block.reference();
  116.   req->lockId = ptr.p->m_mutexId;
  117.   req->lockKey = ptr.p->m_mutexKey;
  119.   m_block.sendSignal(DBUTIL_REF, 
  120.      GSN_UTIL_DESTROY_LOCK_REQ, 
  121.      signal,
  122.      UtilDestroyLockReq::SignalLength,
  123.      JBB);
  125.   ptr.p->m_gsn = GSN_UTIL_DESTROY_LOCK_REQ;
  126. }
  128. void
  129. SimulatedBlock::MutexManager::execUTIL_DESTORY_LOCK_REF(Signal* signal){
  130.   UtilDestroyLockRef * ref = (UtilDestroyLockRef*)signal->getDataPtr();
  131.   ActiveMutexPtr ptr;
  132.   m_activeMutexes.getPtr(ptr, ref->senderData);
  133.   ndbrequire(ptr.p->m_gsn == GSN_UTIL_DESTROY_LOCK_REQ);
  134.   ndbrequire(ptr.p->m_mutexId == ref->lockId);
  136.   ptr.p->m_gsn = 0;
  137.   m_block.execute(signal, ptr.p->m_callback, ref->errorCode);
  138. }
  140. void
  141. SimulatedBlock::MutexManager::execUTIL_DESTORY_LOCK_CONF(Signal* signal){
  142.   UtilDestroyLockConf * conf = (UtilDestroyLockConf*)signal->getDataPtr();
  143.   ActiveMutexPtr ptr;
  144.   m_activeMutexes.getPtr(ptr, conf->senderData);
  145.   ndbrequire(ptr.p->m_gsn == GSN_UTIL_DESTROY_LOCK_REQ);
  146.   ndbrequire(ptr.p->m_mutexId == conf->lockId);
  148.   ptr.p->m_gsn = 0;
  149.   m_block.execute(signal, ptr.p->m_callback, 0);
  150. }
  153. void 
  154. SimulatedBlock::MutexManager::lock(Signal* signal, ActiveMutexPtr& ptr){
  156.   UtilLockReq * req = (UtilLockReq*)signal->getDataPtrSend();
  157.   req->senderData = ptr.i;
  158.   req->senderRef = m_block.reference();
  159.   req->lockId = ptr.p->m_mutexId;
  160.   req->requestInfo = 0;
  161.   
  162.   m_block.sendSignal(DBUTIL_REF, 
  163.      GSN_UTIL_LOCK_REQ, 
  164.      signal,
  165.      UtilLockReq::SignalLength,
  166.      JBB);
  167.   
  168.   ptr.p->m_gsn = GSN_UTIL_LOCK_REQ;
  169. }
  171. void 
  172. SimulatedBlock::MutexManager::trylock(Signal* signal, ActiveMutexPtr& ptr){
  174.   UtilLockReq * req = (UtilLockReq*)signal->getDataPtrSend();
  175.   req->senderData = ptr.i;
  176.   req->senderRef = m_block.reference();
  177.   req->lockId = ptr.p->m_mutexId;
  178.   req->requestInfo = UtilLockReq::TryLock;
  179.   
  180.   m_block.sendSignal(DBUTIL_REF, 
  181.      GSN_UTIL_LOCK_REQ, 
  182.      signal,
  183.      UtilLockReq::SignalLength,
  184.      JBB);
  185.   
  186.   ptr.p->m_gsn = GSN_UTIL_LOCK_REQ;
  187. }
  189. void
  190. SimulatedBlock::MutexManager::execUTIL_LOCK_REF(Signal* signal){
  191.   UtilLockRef * ref = (UtilLockRef*)signal->getDataPtr();
  192.   ActiveMutexPtr ptr;
  193.   m_activeMutexes.getPtr(ptr, ref->senderData);
  194.   ndbrequire(ptr.p->m_gsn == GSN_UTIL_LOCK_REQ);
  195.   ndbrequire(ptr.p->m_mutexId == ref->lockId);
  197.   ptr.p->m_gsn = 0;
  198.   m_block.execute(signal, ptr.p->m_callback, ref->errorCode);
  199. }
  201. void
  202. SimulatedBlock::MutexManager::execUTIL_LOCK_CONF(Signal* signal){
  203.   UtilLockConf * conf = (UtilLockConf*)signal->getDataPtr();
  204.   ActiveMutexPtr ptr;
  205.   m_activeMutexes.getPtr(ptr, conf->senderData);
  206.   ndbrequire(ptr.p->m_gsn == GSN_UTIL_LOCK_REQ);
  207.   ndbrequire(ptr.p->m_mutexId == conf->lockId);
  209.   ptr.p->m_mutexKey = conf->lockKey;
  211.   ptr.p->m_gsn = 0;
  212.   m_block.execute(signal, ptr.p->m_callback, 0);
  213. }
  215. void 
  216. SimulatedBlock::MutexManager::unlock(Signal* signal, ActiveMutexPtr& ptr){
  217.   UtilUnlockReq * req = (UtilUnlockReq*)signal->getDataPtrSend();
  218.   req->senderData = ptr.i;
  219.   req->senderRef = m_block.reference();
  220.   req->lockId = ptr.p->m_mutexId;
  221.   req->lockKey = ptr.p->m_mutexKey;
  222.   
  223.   m_block.sendSignal(DBUTIL_REF, 
  224.      GSN_UTIL_UNLOCK_REQ, 
  225.      signal,
  226.      UtilUnlockReq::SignalLength,
  227.      JBB);
  228.   
  229.   ptr.p->m_gsn = GSN_UTIL_UNLOCK_REQ;
  230. }
  232. void
  233. SimulatedBlock::MutexManager::execUTIL_UNLOCK_REF(Signal* signal){
  234.   UtilUnlockRef * ref = (UtilUnlockRef*)signal->getDataPtr();
  235.   ActiveMutexPtr ptr;
  236.   m_activeMutexes.getPtr(ptr, ref->senderData);
  237.   ndbrequire(ptr.p->m_gsn == GSN_UTIL_UNLOCK_REQ);
  238.   ndbrequire(ptr.p->m_mutexId == ref->lockId);
  240.   ptr.p->m_gsn = 0;
  241.   m_block.execute(signal, ptr.p->m_callback, ref->errorCode);
  242. }
  244. void
  245. SimulatedBlock::MutexManager::execUTIL_UNLOCK_CONF(Signal* signal){
  246.   UtilUnlockConf * conf = (UtilUnlockConf*)signal->getDataPtr();
  247.   ActiveMutexPtr ptr;
  248.   m_activeMutexes.getPtr(ptr, conf->senderData);
  249.   ndbrequire(ptr.p->m_gsn == GSN_UTIL_UNLOCK_REQ);
  250.   ndbrequire(ptr.p->m_mutexId == conf->lockId);
  252.   ptr.p->m_gsn = 0;
  253.   m_block.execute(signal, ptr.p->m_callback, 0);
  254. }
  256. void
  257. Mutex::release(SimulatedBlock::MutexManager& mgr, 
  258.        Uint32 activePtrI, Uint32 mutexId){
  259.   SimulatedBlock::MutexManager::ActiveMutexPtr ptr;
  260.   ptr.i = activePtrI;
  261.   mgr.getPtr(ptr);
  262.   if(ptr.p->m_gsn == 0 && ptr.p->m_mutexId == mutexId){
  263.     mgr.release(activePtrI);
  264.     return;
  265.   }
  266.   
  267.   if(ptr.p->m_mutexId != mutexId)
  268.     ErrorReporter::handleAssert("MutexHandle::release invalid handle", 
  269. __FILE__, __LINE__);
  270.   ErrorReporter::handleAssert("MutexHandle::release of mutex inuse", 
  271.       __FILE__, __LINE__);
  272. }
  274. void
  275. Mutex::unlock(){
  276.   if(!m_ptr.isNull()){
  277.     m_mgr.getPtr(m_ptr);
  278.     if(m_ptr.p->m_mutexId == m_mutexId){
  279.       SimulatedBlock::Callback c = 
  280. { &SimulatedBlock::ignoreMutexUnlockCallback, m_ptr.i };
  281.       m_ptr.p->m_callback = c;
  282.       m_mgr.unlock(m_signal, m_ptr);
  283.       m_ptr.setNull(); // Remove reference
  284.     }
  285.   }
  286. }