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
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
|
/*
* Copyright (C) 2012 10gen 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 here.
*/
#pragma once
#include "mongo/base/disallow_copying.h"
#include "mongo/db/jsobj.h"
#include "mongo/platform/atomic_word.h"
#include "mongo/util/concurrency/mutex.h"
namespace mongo {
/**
* A simple thread-safe fail point implementation that can be activated and
* deactivated, as well as embed temporary data into it.
*
* The fail point has a static instance, which is represented by a FailPoint
* object, and dynamic instance, which are all the threads in between
* shouldFailOpenBlock and shouldFailCloseBlock.
*
* Sample use:
* // Declared somewhere:
* FailPoint makeBadThingsHappen;
*
* // Somewhere in the code
* return false || MONGO_FAIL_POINT(makeBadThingsHappen);
*
* or
*
* // Somewhere in the code
* MONGO_FAIL_POINT_BLOCK(makeBadThingsHappen, blockMakeBadThingsHappen) {
* const BSONObj& data = blockMakeBadThingsHappen.getData();
* // Do something
* }
*
* Invariants:
*
* 1. Always refer to _fpInfo first to check if failPoint is active or not before
* entering fail point or modifying fail point.
* 2. Client visible fail point states are read-only when active.
*/
class FailPoint {
MONGO_DISALLOW_COPYING(FailPoint);
public:
typedef AtomicUInt32::WordType ValType;
enum Mode { off, alwaysOn, random, nTimes, numModes };
enum RetCode { fastOff = 0, slowOff, slowOn };
FailPoint();
/**
* Note: This is not side-effect free - it can change the state to OFF after calling.
*
* @return true if fail point is active.
*/
inline bool shouldFail() {
RetCode ret = shouldFailOpenBlock();
if (MONGO_likely(ret == fastOff)) {
return false;
}
shouldFailCloseBlock();
return ret == slowOn;
}
/**
* Checks whether fail point is active and increments the reference counter without
* decrementing it. Must call shouldFailCloseBlock afterwards when the return value
* is not fastOff. Otherwise, this will remain read-only forever.
*
* @return slowOn if fail point is active.
*/
inline RetCode shouldFailOpenBlock() {
if (MONGO_likely((_fpInfo.loadRelaxed() & ACTIVE_BIT) == 0)) {
return fastOff;
}
return slowShouldFailOpenBlock();
}
/**
* Decrements the reference counter.
* @see #shouldFailOpenBlock
*/
void shouldFailCloseBlock();
/**
* Changes the settings of this fail point. This will turn off the fail point
* and waits for all dynamic instances referencing this fail point to go away before
* actually modifying the settings.
*
* @param mode the new mode for this fail point.
* @param val the value that can have different usage depending on the mode:
*
* - off, alwaysOn: ignored
* - random:
* - nTimes: the number of times this fail point will be active when
* #shouldFail or #shouldFailOpenBlock is called.
*
* @param extra arbitrary BSON object that can be stored to this fail point
* that can be referenced afterwards with #getData. Defaults to an empty
* document.
*/
void setMode(Mode mode, ValType val = 0, const BSONObj& extra = BSONObj());
/**
* @returns a BSON object showing the current mode and data stored.
*/
BSONObj toBSON() const;
private:
static const ValType ACTIVE_BIT = 1 << 31;
static const ValType REF_COUNTER_MASK = ~ACTIVE_BIT;
// Bit layout:
// 31: tells whether this fail point is active.
// 0~30: unsigned ref counter for active dynamic instances.
AtomicUInt32 _fpInfo;
// Invariant: These should be read only if ACTIVE_BIT of _fpInfo is set.
Mode _mode;
AtomicInt32 _timesOrPeriod;
BSONObj _data;
// protects _mode, _timesOrPeriod, _data
mutable mutex _modMutex;
/**
* Enables this fail point.
*/
void enableFailPoint();
/**
* Disables this fail point.
*/
void disableFailPoint();
/**
* slow path for #shouldFailOpenBlock
*/
RetCode slowShouldFailOpenBlock();
/**
* @return the stored BSONObj in this fail point. Note that this cannot be safely
* read if this fail point is off.
*/
const BSONObj& getData() const;
friend class ScopedFailPoint;
};
/**
* Helper class for making sure that FailPoint#shouldFailCloseBlock is called when
* FailPoint#shouldFailOpenBlock was called. This should only be used within the
* MONGO_FAIL_POINT_BLOCK macro.
*/
class ScopedFailPoint {
MONGO_DISALLOW_COPYING(ScopedFailPoint);
public:
ScopedFailPoint(FailPoint* failPoint);
~ScopedFailPoint();
/**
* @return true if fail point is on. This will be true at most once.
*/
inline bool isActive() {
if (_once) {
return false;
}
_once = true;
FailPoint::RetCode ret = _failPoint->shouldFailOpenBlock();
_shouldClose = ret != FailPoint::fastOff;
return ret == FailPoint::slowOn;
}
/**
* @return the data stored in the fail point. #isActive must be true
* before you can call this.
*/
const BSONObj& getData() const;
private:
FailPoint* _failPoint;
bool _once;
bool _shouldClose;
};
#define MONGO_FAIL_POINT(symbol) MONGO_unlikely(symbol.shouldFail())
/**
* Macro for creating a fail point with block context. Also use this when
* you want to access the data stored in the fail point.
*/
#define MONGO_FAIL_POINT_BLOCK(symbol, blockSymbol) \
for (mongo::ScopedFailPoint blockSymbol(&symbol); \
MONGO_unlikely(blockSymbol.isActive()); )
}
|
