1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
|
/**
* Copyright (C) 2018 MongoDB Inc.
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU Affero General Public License, version 3,
* as published by the Free Software Foundation.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Affero General Public License for more details.
*
* You should have received a copy of the GNU Affero General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*
* As a special exception, the copyright holders give permission to link the
* code of portions of this program with the OpenSSL library under certain
* conditions as described in each individual source file and distribute
* linked combinations including the program with the OpenSSL library. You
* must comply with the GNU Affero General Public License in all respects for
* all of the code used other than as permitted herein. If you modify file(s)
* with this exception, you may extend this exception to your version of the
* file(s), but you are not obligated to do so. If you do not wish to do so,
* delete this exception statement from your version. If you delete this
* exception statement from all source files in the program, then also delete
* it in the license file.
*/
#define MONGO_LOG_DEFAULT_COMPONENT ::mongo::logger::LogComponent::kDefault
#include "mongo/platform/basic.h"
#include "mongo/db/concurrency/replication_lock_manager_manipulator.h"
namespace mongo {
ReplicationLockManagerManipulator::ReplicationLockManagerManipulator(LockManager* lockManager)
: _lockManager(lockManager) {}
void ReplicationLockManagerManipulator::lockUncontestedTemporaryGlobalResource(
LockManager::TemporaryResourceQueue* tempGlobalResource, LockRequest* request, LockMode mode) {
// Sanity check that requests are not being reused without proper cleanup
invariant(request->status == LockRequest::STATUS_NEW);
invariant(request->recursiveCount == 1);
invariant(!request->partitioned);
invariant(tempGlobalResource->_lockHead.resourceId.getType() == ResourceType::RESOURCE_GLOBAL);
request->mode = mode;
const auto lockResult = tempGlobalResource->_lockHead.newRequest(request);
invariant(lockResult == LockResult::LOCK_OK);
}
void ReplicationLockManagerManipulator::replaceGlobalLocksWithLocksFromTemporaryGlobalResource(
ResourceId resId, LockManager::TemporaryResourceQueue* tempGlobalResource) {
invariant(resId.getType() == ResourceType::RESOURCE_GLOBAL);
invariant(tempGlobalResource->_lockHead.resourceId == resId);
LockManager::LockBucket* bucket = _lockManager->_getBucket(resId);
stdx::lock_guard<SimpleMutex> scopedLock(bucket->mutex);
LockHead* trueGlobalLockHead = bucket->findOrInsert(resId);
LockHead* tempGlobalLockHead = &tempGlobalResource->_lockHead;
invariant(trueGlobalLockHead->grantedCounts[MODE_X] == 1);
invariant(trueGlobalLockHead->compatibleFirstCount == 1);
invariant(tempGlobalLockHead->conflictList.empty());
LockRequest* existingGlobalLockRequest = trueGlobalLockHead->grantedList._front;
invariant(!existingGlobalLockRequest->next);
invariant(existingGlobalLockRequest->mode == MODE_X);
invariant(existingGlobalLockRequest->status == LockRequest::Status::STATUS_GRANTED);
// Remove the existing granted MODE_X lock from the trueGlobalLockHead so it can be replaced
// by the locks from tempGlobalLockHead.
trueGlobalLockHead->grantedList.remove(existingGlobalLockRequest);
trueGlobalLockHead->decGrantedModeCount(existingGlobalLockRequest->mode);
trueGlobalLockHead->compatibleFirstCount--;
// Now iterate over the granted LockRequests in the tempGlobalLockHead and transfer them over
// to the trueGlobalLockHead.
for (LockRequest* it = tempGlobalLockHead->grantedList._front; it != nullptr;) {
LockRequest* next = it->next;
invariant(it->mode == MODE_IX);
invariant(it->status == LockRequest::Status::STATUS_GRANTED);
invariant(it->lock == tempGlobalLockHead);
it->lock = trueGlobalLockHead;
tempGlobalLockHead->grantedList.remove(it);
tempGlobalLockHead->decGrantedModeCount(it->mode);
trueGlobalLockHead->grantedList.push_back(it);
trueGlobalLockHead->incGrantedModeCount(it->mode);
it = next;
}
invariant(tempGlobalLockHead->grantedList.empty());
invariant(tempGlobalLockHead->grantedCounts[MODE_X] == 0);
invariant(tempGlobalLockHead->grantedModes == 0);
// Grant any pending requests against the true global lock head that can proceed now that the
// global X lock has been released.
_lockManager->_onLockModeChanged(trueGlobalLockHead, true);
}
} // namespace mongo
|
