blob: d97c1a3959411ff4339c8c6ce3a0c679afb11e18 (
plain)
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
|
/*
* Copyright (C) 2010 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/>.
*/
#pragma once
#include <boost/thread/condition.hpp>
#include <boost/thread/mutex.hpp>
#include "mongo/bson/util/atomic_int.h"
#include "mongo/base/disallow_copying.h"
namespace mongo {
/* _globalKill: we are shutting down
otherwise kill attribute set on specified CurOp
this class does not handle races between interruptJs and the checkForInterrupt functions - those must be
handled by the client of this class
*/
class KillCurrentOp {
MONGO_DISALLOW_COPYING(KillCurrentOp);
public:
KillCurrentOp() : _globalKill(false) {}
void killAll();
/**
* @param i opid of operation to kill
* @return if operation was found
**/
bool kill(AtomicUInt i);
/**
* blocks until kill is acknowledged by the killee.
*
* Note: Does not wait for nested ops, only the top level op.
*/
void blockingKill(AtomicUInt opId);
/** @return true if global interrupt and should terminate the operation */
bool globalInterruptCheck() const { return _globalKill; }
/**
* @param heedMutex if true and have a write lock, won't kill op since it might be unsafe
*/
void checkForInterrupt( bool heedMutex = true );
/** @return "" if not interrupted. otherwise, you should stop. */
const char *checkForInterruptNoAssert();
/** set all flags for all the threads waiting for the current thread's operation to
* end; part of internal synchronous kill mechanism
**/
void notifyAllWaiters();
/** Reset the object to its initial state. Only for testing. */
void reset();
private:
void interruptJs( AtomicUInt *op );
volatile bool _globalKill;
boost::condition _condvar;
boost::mutex _mtx;
/**
* @param i opid of operation to kill
* @param pNotifyFlag optional bool to be set to true when kill actually happens
* @return if operation was found
**/
bool _killImpl_inclientlock(AtomicUInt i, bool* pNotifyFlag = NULL);
};
extern KillCurrentOp killCurrentOp;
}
|
