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
|
/**
* Copyright (C) 2018-present MongoDB, Inc.
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the Server Side Public License, version 1,
* as published by MongoDB, Inc.
*
* 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
* Server Side Public License for more details.
*
* You should have received a copy of the Server Side Public License
* along with this program. If not, see
* <http://www.mongodb.com/licensing/server-side-public-license>.
*
* 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 Server Side 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.
*/
#pragma once
#include <utility>
#include "mongo/db/catalog/util/partitioned.h"
#include "mongo/db/clientcursor.h"
#include "mongo/db/cursor_id.h"
#include "mongo/db/generic_cursor.h"
#include "mongo/db/kill_sessions.h"
#include "mongo/db/namespace_string.h"
#include "mongo/db/record_id.h"
#include "mongo/db/session_killer.h"
#include "mongo/stdx/unordered_map.h"
#include "mongo/stdx/unordered_set.h"
#include "mongo/util/concurrency/mutex.h"
#include "mongo/util/duration.h"
namespace mongo {
class AuthorizationSession;
class OperationContext;
class PseudoRandom;
class PlanExecutor;
/**
* A container which owns ClientCursor objects. This class is used to create, access, and delete
* ClientCursors. It is also responsible for allocating the cursor ids that are passed back to
* clients.
*
* There is a process-global CursorManager on every mongod which is responsible for managing all
* open cursors on the node. No lock manager locks are required to access this global cursor
* manager. The CursorManager is internally synchronized, and unless otherwise noted its public
* methods are thread-safe. For scalability in circumstances where many threads may be concurrently
* accessing the CursorManager (i.e. a workload which runs many concurrent queries), the cursor
* manager's underlying data structure is partitioned. Each partition is protected by its own latch.
*
* See clientcursor.h for more information.
*/
class CursorManager {
public:
/**
* Returns a pointer to the cursor manager defined within the specified ServiceContext.
*/
static CursorManager* get(ServiceContext* svcCtx);
/**
* Returns a pointer to the cursor manager defined within the specified OperationContext.
*/
static CursorManager* get(OperationContext* opCtx);
/**
* Registers the new cursor manager within the specified ServiceContext.
*/
static void set(ServiceContext* svcCtx, std::unique_ptr<CursorManager> newCursorManager);
CursorManager();
/**
* Destroys the cursor manager, deleting all managed cursors. Illegal to call if any managed
* cursor is pinned.
*/
~CursorManager();
/**
* Destroys cursors that have been inactive for too long.
*
* Returns the number of cursors that were timed out.
*/
std::size_t timeoutCursors(OperationContext* opCtx, Date_t now);
/**
* Constructs a new ClientCursor according to the given 'cursorParams'. The cursor is atomically
* registered with the manager and returned in pinned state.
*/
ClientCursorPin registerCursor(OperationContext* opCtx, ClientCursorParams&& cursorParams);
/**
* Pins and returns the cursor with the given id.
*
* Returns ErrorCodes::CursorNotFound if the cursor does not exist or
* ErrorCodes::QueryPlanKilled if the cursor was killed in between uses.
*
* Throws a AssertionException if the cursor is already pinned. Callers need not specially
* handle this error, as it should only happen if a misbehaving client attempts to
* simultaneously issue two operations against the same cursor id.
*/
enum AuthCheck { kCheckSession = true, kNoCheckSession = false };
StatusWith<ClientCursorPin> pinCursor(OperationContext* opCtx,
CursorId id,
AuthCheck checkSessionAuth = kCheckSession);
/**
* Returns an OK status if the cursor was successfully killed, meaning either:
* (1) The cursor was erased from the cursor registry
* (2) The cursor's operation was interrupted, and the cursor will be cleaned up when the
* operation next checks for interruption.
* Case (2) will only occur if the cursor is pinned.
*
* Returns ErrorCodes::CursorNotFound if the cursor id is not owned by this manager. Returns
* ErrorCodes::OperationFailed if attempting to erase a pinned cursor.
*
* If 'shouldAudit' is true, will perform audit logging.
*/
Status killCursor(OperationContext* opCtx, CursorId id, bool shouldAudit);
/**
* Returns an OK status if we're authorized to erase the cursor. Otherwise, returns
* ErrorCodes::Unauthorized.
*/
Status checkAuthForKillCursors(OperationContext* opCtx, CursorId id);
/**
* Appends sessions that have open cursors in this cursor manager to the given set of lsids.
* 'userMode': If auth is on, calling with userMode as kExcludeOthers will cause this function
* to only return cursors owned by the caller. If auth is off, this argument does not matter.
*/
void appendActiveSessions(LogicalSessionIdSet* lsids) const;
/**
* Returns a vector of all idle (non-pinned) cursors in this cursor manager.
*
* If auth is on, calling with 'userMode' as 'kExcludeOthers' will cause this function to only
* return cursors owned by the caller. If auth is off, this argument does not matter.
*/
std::vector<GenericCursor> getIdleCursors(
OperationContext* opCtx, MongoProcessInterface::CurrentOpUserMode userMode) const;
/*
* Returns a list of all open cursors for the given session.
*/
stdx::unordered_set<CursorId> getCursorsForSession(LogicalSessionId lsid) const;
/**
* Returns the number of ClientCursors currently registered.
*/
std::size_t numCursors() const;
/**
* Kills cursors in this cursor manager with matching logical sessions. Returns a pair with the
* overall Status of the operation and the number of cursors successfully killed.
*/
std::pair<Status, int> killCursorsWithMatchingSessions(OperationContext* opCtx,
const SessionKiller::Matcher& matcher);
private:
static constexpr int kNumPartitions = 16;
friend class ClientCursorPin;
CursorId allocateCursorId_inlock();
ClientCursorPin _registerCursor(
OperationContext* opCtx, std::unique_ptr<ClientCursor, ClientCursor::Deleter> clientCursor);
void deregisterCursor(ClientCursor* cursor);
void deregisterAndDestroyCursor(
Partitioned<stdx::unordered_map<CursorId, ClientCursor*>, kNumPartitions>::OnePartition&&,
OperationContext* opCtx,
std::unique_ptr<ClientCursor, ClientCursor::Deleter> cursor);
void unpin(OperationContext* opCtx,
std::unique_ptr<ClientCursor, ClientCursor::Deleter> cursor);
bool cursorShouldTimeout_inlock(const ClientCursor* cursor, Date_t now);
// A CursorManager holds a pointer to all open ClientCursors. ClientCursors are owned by the
// CursorManager, except when they are in use by a ClientCursorPin. When in use by a pin, an
// unowned pointer remains to ensure they still receive kill notifications while in use.
//
// There are several mutexes at work to protect concurrent access to data structures managed by
// this cursor manager. The '_cursorMap' is partitioned to decrease contention, and each
// partition of the structure is protected by its own mutex. Separately, there is a
// '_registrationLock' which protects concurrent access to '_random' for cursor id generation,
// and must be held from cursor id generation until insertion into '_cursorMap'. If you ever
// need to acquire more than one of these mutexes at once, you must follow the following rules:
// - '_registrationLock' must be acquired first, if at all.
// - Mutex(es) for '_cursorMap' must be acquired next.
// - If you need to access multiple partitions within '_cursorMap' at once, you must acquire the
// mutexes for those partitions in ascending order, or use the partition helpers to acquire
// mutexes for all partitions.
mutable SimpleMutex _registrationLock;
std::unique_ptr<PseudoRandom> _random;
std::unique_ptr<Partitioned<stdx::unordered_map<CursorId, ClientCursor*>, kNumPartitions>>
_cursorMap;
};
} // namespace mongo
|
