Commit | Line | Data |
---|---|---|
f2145eae BK |
1 | /* -*- buffer-read-only: t -*- vi: set ro: |
2 | * | |
3 | * DO NOT EDIT THIS FILE (lustre_dlm_flags.h) | |
4 | * | |
5 | * It has been AutoGen-ed | |
6 | * From the definitions lustre_dlm_flags.def | |
7 | * and the template file lustre_dlm_flags.tpl | |
8 | * | |
9 | * lustre is free software: you can redistribute it and/or modify it | |
10 | * under the terms of the GNU General Public License as published by the | |
11 | * Free Software Foundation, either version 3 of the License, or | |
12 | * (at your option) any later version. | |
13 | * | |
14 | * lustre is distributed in the hope that it will be useful, but | |
15 | * WITHOUT ANY WARRANTY; without even the implied warranty of | |
16 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. | |
17 | * See the GNU General Public License for more details. | |
18 | * | |
19 | * You should have received a copy of the GNU General Public License along | |
20 | * with this program. If not, see <http://www.gnu.org/licenses/>. | |
21 | */ | |
22 | /** | |
23 | * \file lustre_dlm_flags.h | |
24 | * The flags and collections of flags (masks) for \see struct ldlm_lock. | |
25 | * This file is derived from flag definitions in lustre_dlm_flags.def. | |
26 | * The format is defined in the lustre_dlm_flags.tpl template file. | |
27 | * | |
28 | * \addtogroup LDLM Lustre Distributed Lock Manager | |
29 | * @{ | |
30 | * | |
31 | * \name flags | |
32 | * The flags and collections of flags (masks) for \see struct ldlm_lock. | |
33 | * @{ | |
34 | */ | |
35 | #ifndef LDLM_ALL_FLAGS_MASK | |
36 | ||
37 | /** l_flags bits marked as "all_flags" bits */ | |
69342b78 | 38 | #define LDLM_FL_ALL_FLAGS_MASK 0x00FFFFFFC08F932FULL |
f2145eae BK |
39 | |
40 | /** l_flags bits marked as "ast" bits */ | |
69342b78 | 41 | #define LDLM_FL_AST_MASK 0x0000000080008000ULL |
f2145eae BK |
42 | |
43 | /** l_flags bits marked as "blocked" bits */ | |
44 | #define LDLM_FL_BLOCKED_MASK 0x000000000000000EULL | |
45 | ||
46 | /** l_flags bits marked as "gone" bits */ | |
47 | #define LDLM_FL_GONE_MASK 0x0006004000000000ULL | |
48 | ||
49 | /** l_flags bits marked as "hide_lock" bits */ | |
50 | #define LDLM_FL_HIDE_LOCK_MASK 0x0000206400000000ULL | |
51 | ||
52 | /** l_flags bits marked as "inherit" bits */ | |
53 | #define LDLM_FL_INHERIT_MASK 0x0000000000800000ULL | |
54 | ||
55 | /** l_flags bits marked as "local_only" bits */ | |
d3a8a4e2 | 56 | #define LDLM_FL_LOCAL_ONLY_MASK 0x00FFFFFF00000000ULL |
f2145eae BK |
57 | |
58 | /** l_flags bits marked as "on_wire" bits */ | |
69342b78 | 59 | #define LDLM_FL_ON_WIRE_MASK 0x00000000C08F932FULL |
f2145eae BK |
60 | |
61 | /** extent, mode, or resource changed */ | |
62 | #define LDLM_FL_LOCK_CHANGED 0x0000000000000001ULL // bit 0 | |
63 | #define ldlm_is_lock_changed(_l) LDLM_TEST_FLAG(( _l), 1ULL << 0) | |
64 | #define ldlm_set_lock_changed(_l) LDLM_SET_FLAG(( _l), 1ULL << 0) | |
65 | #define ldlm_clear_lock_changed(_l) LDLM_CLEAR_FLAG((_l), 1ULL << 0) | |
66 | ||
67 | /** | |
68 | * Server placed lock on granted list, or a recovering client wants the | |
69 | * lock added to the granted list, no questions asked. */ | |
70 | #define LDLM_FL_BLOCK_GRANTED 0x0000000000000002ULL // bit 1 | |
71 | #define ldlm_is_block_granted(_l) LDLM_TEST_FLAG(( _l), 1ULL << 1) | |
72 | #define ldlm_set_block_granted(_l) LDLM_SET_FLAG(( _l), 1ULL << 1) | |
73 | #define ldlm_clear_block_granted(_l) LDLM_CLEAR_FLAG((_l), 1ULL << 1) | |
74 | ||
75 | /** | |
76 | * Server placed lock on conv list, or a recovering client wants the lock | |
77 | * added to the conv list, no questions asked. */ | |
78 | #define LDLM_FL_BLOCK_CONV 0x0000000000000004ULL // bit 2 | |
79 | #define ldlm_is_block_conv(_l) LDLM_TEST_FLAG(( _l), 1ULL << 2) | |
80 | #define ldlm_set_block_conv(_l) LDLM_SET_FLAG(( _l), 1ULL << 2) | |
81 | #define ldlm_clear_block_conv(_l) LDLM_CLEAR_FLAG((_l), 1ULL << 2) | |
82 | ||
83 | /** | |
84 | * Server placed lock on wait list, or a recovering client wants the lock | |
85 | * added to the wait list, no questions asked. */ | |
86 | #define LDLM_FL_BLOCK_WAIT 0x0000000000000008ULL // bit 3 | |
87 | #define ldlm_is_block_wait(_l) LDLM_TEST_FLAG(( _l), 1ULL << 3) | |
88 | #define ldlm_set_block_wait(_l) LDLM_SET_FLAG(( _l), 1ULL << 3) | |
89 | #define ldlm_clear_block_wait(_l) LDLM_CLEAR_FLAG((_l), 1ULL << 3) | |
90 | ||
91 | /** blocking or cancel packet was queued for sending. */ | |
92 | #define LDLM_FL_AST_SENT 0x0000000000000020ULL // bit 5 | |
93 | #define ldlm_is_ast_sent(_l) LDLM_TEST_FLAG(( _l), 1ULL << 5) | |
94 | #define ldlm_set_ast_sent(_l) LDLM_SET_FLAG(( _l), 1ULL << 5) | |
95 | #define ldlm_clear_ast_sent(_l) LDLM_CLEAR_FLAG((_l), 1ULL << 5) | |
96 | ||
97 | /** | |
98 | * Lock is being replayed. This could probably be implied by the fact that | |
99 | * one of BLOCK_{GRANTED,CONV,WAIT} is set, but that is pretty dangerous. */ | |
100 | #define LDLM_FL_REPLAY 0x0000000000000100ULL // bit 8 | |
101 | #define ldlm_is_replay(_l) LDLM_TEST_FLAG(( _l), 1ULL << 8) | |
102 | #define ldlm_set_replay(_l) LDLM_SET_FLAG(( _l), 1ULL << 8) | |
103 | #define ldlm_clear_replay(_l) LDLM_CLEAR_FLAG((_l), 1ULL << 8) | |
104 | ||
105 | /** Don't grant lock, just do intent. */ | |
106 | #define LDLM_FL_INTENT_ONLY 0x0000000000000200ULL // bit 9 | |
107 | #define ldlm_is_intent_only(_l) LDLM_TEST_FLAG(( _l), 1ULL << 9) | |
108 | #define ldlm_set_intent_only(_l) LDLM_SET_FLAG(( _l), 1ULL << 9) | |
109 | #define ldlm_clear_intent_only(_l) LDLM_CLEAR_FLAG((_l), 1ULL << 9) | |
110 | ||
111 | /** lock request has intent */ | |
112 | #define LDLM_FL_HAS_INTENT 0x0000000000001000ULL // bit 12 | |
113 | #define ldlm_is_has_intent(_l) LDLM_TEST_FLAG(( _l), 1ULL << 12) | |
114 | #define ldlm_set_has_intent(_l) LDLM_SET_FLAG(( _l), 1ULL << 12) | |
115 | #define ldlm_clear_has_intent(_l) LDLM_CLEAR_FLAG((_l), 1ULL << 12) | |
116 | ||
69342b78 AS |
117 | /** flock deadlock detected */ |
118 | #define LDLM_FL_FLOCK_DEADLOCK 0x0000000000008000ULL /* bit 15 */ | |
119 | #define ldlm_is_flock_deadlock(_l) LDLM_TEST_FLAG((_l), 1ULL << 15) | |
120 | #define ldlm_set_flock_deadlock(_l) LDLM_SET_FLAG((_l), 1ULL << 15) | |
121 | #define ldlm_clear_flock_deadlock(_l) LDLM_CLEAR_FLAG((_l), 1ULL << 15) | |
122 | ||
f2145eae BK |
123 | /** discard (no writeback) on cancel */ |
124 | #define LDLM_FL_DISCARD_DATA 0x0000000000010000ULL // bit 16 | |
125 | #define ldlm_is_discard_data(_l) LDLM_TEST_FLAG(( _l), 1ULL << 16) | |
126 | #define ldlm_set_discard_data(_l) LDLM_SET_FLAG(( _l), 1ULL << 16) | |
127 | #define ldlm_clear_discard_data(_l) LDLM_CLEAR_FLAG((_l), 1ULL << 16) | |
128 | ||
129 | /** Blocked by group lock - wait indefinitely */ | |
130 | #define LDLM_FL_NO_TIMEOUT 0x0000000000020000ULL // bit 17 | |
131 | #define ldlm_is_no_timeout(_l) LDLM_TEST_FLAG(( _l), 1ULL << 17) | |
132 | #define ldlm_set_no_timeout(_l) LDLM_SET_FLAG(( _l), 1ULL << 17) | |
133 | #define ldlm_clear_no_timeout(_l) LDLM_CLEAR_FLAG((_l), 1ULL << 17) | |
134 | ||
135 | /** | |
136 | * Server told not to wait if blocked. For AGL, OST will not send glimpse | |
137 | * callback. */ | |
138 | #define LDLM_FL_BLOCK_NOWAIT 0x0000000000040000ULL // bit 18 | |
139 | #define ldlm_is_block_nowait(_l) LDLM_TEST_FLAG(( _l), 1ULL << 18) | |
140 | #define ldlm_set_block_nowait(_l) LDLM_SET_FLAG(( _l), 1ULL << 18) | |
141 | #define ldlm_clear_block_nowait(_l) LDLM_CLEAR_FLAG((_l), 1ULL << 18) | |
142 | ||
143 | /** return blocking lock */ | |
144 | #define LDLM_FL_TEST_LOCK 0x0000000000080000ULL // bit 19 | |
145 | #define ldlm_is_test_lock(_l) LDLM_TEST_FLAG(( _l), 1ULL << 19) | |
146 | #define ldlm_set_test_lock(_l) LDLM_SET_FLAG(( _l), 1ULL << 19) | |
147 | #define ldlm_clear_test_lock(_l) LDLM_CLEAR_FLAG((_l), 1ULL << 19) | |
148 | ||
149 | /** | |
17891183 | 150 | * Immediately cancel such locks when they block some other locks. Send |
f2145eae BK |
151 | * cancel notification to original lock holder, but expect no reply. This |
152 | * is for clients (like liblustre) that cannot be expected to reliably | |
153 | * response to blocking AST. */ | |
154 | #define LDLM_FL_CANCEL_ON_BLOCK 0x0000000000800000ULL // bit 23 | |
155 | #define ldlm_is_cancel_on_block(_l) LDLM_TEST_FLAG(( _l), 1ULL << 23) | |
156 | #define ldlm_set_cancel_on_block(_l) LDLM_SET_FLAG(( _l), 1ULL << 23) | |
157 | #define ldlm_clear_cancel_on_block(_l) LDLM_CLEAR_FLAG((_l), 1ULL << 23) | |
158 | ||
159 | /** | |
160 | * measure lock contention and return -EUSERS if locking contention is high */ | |
161 | #define LDLM_FL_DENY_ON_CONTENTION 0x0000000040000000ULL // bit 30 | |
162 | #define ldlm_is_deny_on_contention(_l) LDLM_TEST_FLAG(( _l), 1ULL << 30) | |
163 | #define ldlm_set_deny_on_contention(_l) LDLM_SET_FLAG(( _l), 1ULL << 30) | |
164 | #define ldlm_clear_deny_on_contention(_l) LDLM_CLEAR_FLAG((_l), 1ULL << 30) | |
165 | ||
166 | /** | |
167 | * These are flags that are mapped into the flags and ASTs of blocking | |
168 | * locks Add FL_DISCARD to blocking ASTs */ | |
169 | #define LDLM_FL_AST_DISCARD_DATA 0x0000000080000000ULL // bit 31 | |
170 | #define ldlm_is_ast_discard_data(_l) LDLM_TEST_FLAG(( _l), 1ULL << 31) | |
171 | #define ldlm_set_ast_discard_data(_l) LDLM_SET_FLAG(( _l), 1ULL << 31) | |
172 | #define ldlm_clear_ast_discard_data(_l) LDLM_CLEAR_FLAG((_l), 1ULL << 31) | |
173 | ||
174 | /** | |
175 | * Used for marking lock as a target for -EINTR while cp_ast sleep emulation | |
176 | * + race with upcoming bl_ast. */ | |
177 | #define LDLM_FL_FAIL_LOC 0x0000000100000000ULL // bit 32 | |
178 | #define ldlm_is_fail_loc(_l) LDLM_TEST_FLAG(( _l), 1ULL << 32) | |
179 | #define ldlm_set_fail_loc(_l) LDLM_SET_FLAG(( _l), 1ULL << 32) | |
180 | #define ldlm_clear_fail_loc(_l) LDLM_CLEAR_FLAG((_l), 1ULL << 32) | |
181 | ||
182 | /** | |
183 | * Used while processing the unused list to know that we have already | |
184 | * handled this lock and decided to skip it. */ | |
185 | #define LDLM_FL_SKIPPED 0x0000000200000000ULL // bit 33 | |
186 | #define ldlm_is_skipped(_l) LDLM_TEST_FLAG(( _l), 1ULL << 33) | |
187 | #define ldlm_set_skipped(_l) LDLM_SET_FLAG(( _l), 1ULL << 33) | |
188 | #define ldlm_clear_skipped(_l) LDLM_CLEAR_FLAG((_l), 1ULL << 33) | |
189 | ||
190 | /** this lock is being destroyed */ | |
191 | #define LDLM_FL_CBPENDING 0x0000000400000000ULL // bit 34 | |
192 | #define ldlm_is_cbpending(_l) LDLM_TEST_FLAG(( _l), 1ULL << 34) | |
193 | #define ldlm_set_cbpending(_l) LDLM_SET_FLAG(( _l), 1ULL << 34) | |
194 | #define ldlm_clear_cbpending(_l) LDLM_CLEAR_FLAG((_l), 1ULL << 34) | |
195 | ||
196 | /** not a real flag, not saved in lock */ | |
197 | #define LDLM_FL_WAIT_NOREPROC 0x0000000800000000ULL // bit 35 | |
198 | #define ldlm_is_wait_noreproc(_l) LDLM_TEST_FLAG(( _l), 1ULL << 35) | |
199 | #define ldlm_set_wait_noreproc(_l) LDLM_SET_FLAG(( _l), 1ULL << 35) | |
200 | #define ldlm_clear_wait_noreproc(_l) LDLM_CLEAR_FLAG((_l), 1ULL << 35) | |
201 | ||
202 | /** cancellation callback already run */ | |
203 | #define LDLM_FL_CANCEL 0x0000001000000000ULL // bit 36 | |
204 | #define ldlm_is_cancel(_l) LDLM_TEST_FLAG(( _l), 1ULL << 36) | |
205 | #define ldlm_set_cancel(_l) LDLM_SET_FLAG(( _l), 1ULL << 36) | |
206 | #define ldlm_clear_cancel(_l) LDLM_CLEAR_FLAG((_l), 1ULL << 36) | |
207 | ||
208 | /** whatever it might mean */ | |
209 | #define LDLM_FL_LOCAL_ONLY 0x0000002000000000ULL // bit 37 | |
210 | #define ldlm_is_local_only(_l) LDLM_TEST_FLAG(( _l), 1ULL << 37) | |
211 | #define ldlm_set_local_only(_l) LDLM_SET_FLAG(( _l), 1ULL << 37) | |
212 | #define ldlm_clear_local_only(_l) LDLM_CLEAR_FLAG((_l), 1ULL << 37) | |
213 | ||
214 | /** don't run the cancel callback under ldlm_cli_cancel_unused */ | |
215 | #define LDLM_FL_FAILED 0x0000004000000000ULL // bit 38 | |
216 | #define ldlm_is_failed(_l) LDLM_TEST_FLAG(( _l), 1ULL << 38) | |
217 | #define ldlm_set_failed(_l) LDLM_SET_FLAG(( _l), 1ULL << 38) | |
218 | #define ldlm_clear_failed(_l) LDLM_CLEAR_FLAG((_l), 1ULL << 38) | |
219 | ||
220 | /** lock cancel has already been sent */ | |
221 | #define LDLM_FL_CANCELING 0x0000008000000000ULL // bit 39 | |
222 | #define ldlm_is_canceling(_l) LDLM_TEST_FLAG(( _l), 1ULL << 39) | |
223 | #define ldlm_set_canceling(_l) LDLM_SET_FLAG(( _l), 1ULL << 39) | |
224 | #define ldlm_clear_canceling(_l) LDLM_CLEAR_FLAG((_l), 1ULL << 39) | |
225 | ||
226 | /** local lock (ie, no srv/cli split) */ | |
227 | #define LDLM_FL_LOCAL 0x0000010000000000ULL // bit 40 | |
228 | #define ldlm_is_local(_l) LDLM_TEST_FLAG(( _l), 1ULL << 40) | |
229 | #define ldlm_set_local(_l) LDLM_SET_FLAG(( _l), 1ULL << 40) | |
230 | #define ldlm_clear_local(_l) LDLM_CLEAR_FLAG((_l), 1ULL << 40) | |
231 | ||
232 | /** | |
233 | * XXX FIXME: This is being added to b_size as a low-risk fix to the | |
234 | * fact that the LVB filling happens _after_ the lock has been granted, | |
235 | * so another thread can match it before the LVB has been updated. As a | |
236 | * dirty hack, we set LDLM_FL_LVB_READY only after we've done the LVB poop. | |
237 | * this is only needed on LOV/OSC now, where LVB is actually used and | |
238 | * callers must set it in input flags. | |
239 | * | |
240 | * The proper fix is to do the granting inside of the completion AST, | |
241 | * which can be replaced with a LVB-aware wrapping function for OSC locks. | |
242 | * That change is pretty high-risk, though, and would need a lot more | |
243 | * testing. */ | |
244 | #define LDLM_FL_LVB_READY 0x0000020000000000ULL // bit 41 | |
245 | #define ldlm_is_lvb_ready(_l) LDLM_TEST_FLAG(( _l), 1ULL << 41) | |
246 | #define ldlm_set_lvb_ready(_l) LDLM_SET_FLAG(( _l), 1ULL << 41) | |
247 | #define ldlm_clear_lvb_ready(_l) LDLM_CLEAR_FLAG((_l), 1ULL << 41) | |
248 | ||
249 | /** | |
250 | * A lock contributes to the known minimum size (KMS) calculation until it | |
17891183 | 251 | * has finished the part of its cancellation that performs write back on its |
f2145eae BK |
252 | * dirty pages. It can remain on the granted list during this whole time. |
253 | * Threads racing to update the KMS after performing their writeback need | |
254 | * to know to exclude each other's locks from the calculation as they walk | |
255 | * the granted list. */ | |
256 | #define LDLM_FL_KMS_IGNORE 0x0000040000000000ULL // bit 42 | |
257 | #define ldlm_is_kms_ignore(_l) LDLM_TEST_FLAG(( _l), 1ULL << 42) | |
258 | #define ldlm_set_kms_ignore(_l) LDLM_SET_FLAG(( _l), 1ULL << 42) | |
259 | #define ldlm_clear_kms_ignore(_l) LDLM_CLEAR_FLAG((_l), 1ULL << 42) | |
260 | ||
261 | /** completion AST to be executed */ | |
262 | #define LDLM_FL_CP_REQD 0x0000080000000000ULL // bit 43 | |
263 | #define ldlm_is_cp_reqd(_l) LDLM_TEST_FLAG(( _l), 1ULL << 43) | |
264 | #define ldlm_set_cp_reqd(_l) LDLM_SET_FLAG(( _l), 1ULL << 43) | |
265 | #define ldlm_clear_cp_reqd(_l) LDLM_CLEAR_FLAG((_l), 1ULL << 43) | |
266 | ||
267 | /** cleanup_resource has already handled the lock */ | |
268 | #define LDLM_FL_CLEANED 0x0000100000000000ULL // bit 44 | |
269 | #define ldlm_is_cleaned(_l) LDLM_TEST_FLAG(( _l), 1ULL << 44) | |
270 | #define ldlm_set_cleaned(_l) LDLM_SET_FLAG(( _l), 1ULL << 44) | |
271 | #define ldlm_clear_cleaned(_l) LDLM_CLEAR_FLAG((_l), 1ULL << 44) | |
272 | ||
273 | /** | |
274 | * optimization hint: LDLM can run blocking callback from current context | |
275 | * w/o involving separate thread. in order to decrease cs rate */ | |
276 | #define LDLM_FL_ATOMIC_CB 0x0000200000000000ULL // bit 45 | |
277 | #define ldlm_is_atomic_cb(_l) LDLM_TEST_FLAG(( _l), 1ULL << 45) | |
278 | #define ldlm_set_atomic_cb(_l) LDLM_SET_FLAG(( _l), 1ULL << 45) | |
279 | #define ldlm_clear_atomic_cb(_l) LDLM_CLEAR_FLAG((_l), 1ULL << 45) | |
280 | ||
281 | /** | |
282 | * It may happen that a client initiates two operations, e.g. unlink and | |
283 | * mkdir, such that the server sends a blocking AST for conflicting locks | |
284 | * to this client for the first operation, whereas the second operation | |
285 | * has canceled this lock and is waiting for rpc_lock which is taken by | |
286 | * the first operation. LDLM_FL_BL_AST is set by ldlm_callback_handler() in | |
287 | * the lock to prevent the Early Lock Cancel (ELC) code from cancelling it. | |
288 | * | |
289 | * LDLM_FL_BL_DONE is to be set by ldlm_cancel_callback() when lock cache is | |
290 | * dropped to let ldlm_callback_handler() return EINVAL to the server. It | |
291 | * is used when ELC RPC is already prepared and is waiting for rpc_lock, | |
292 | * too late to send a separate CANCEL RPC. */ | |
293 | #define LDLM_FL_BL_AST 0x0000400000000000ULL // bit 46 | |
294 | #define ldlm_is_bl_ast(_l) LDLM_TEST_FLAG(( _l), 1ULL << 46) | |
295 | #define ldlm_set_bl_ast(_l) LDLM_SET_FLAG(( _l), 1ULL << 46) | |
296 | #define ldlm_clear_bl_ast(_l) LDLM_CLEAR_FLAG((_l), 1ULL << 46) | |
297 | ||
298 | /** whatever it might mean */ | |
299 | #define LDLM_FL_BL_DONE 0x0000800000000000ULL // bit 47 | |
300 | #define ldlm_is_bl_done(_l) LDLM_TEST_FLAG(( _l), 1ULL << 47) | |
301 | #define ldlm_set_bl_done(_l) LDLM_SET_FLAG(( _l), 1ULL << 47) | |
302 | #define ldlm_clear_bl_done(_l) LDLM_CLEAR_FLAG((_l), 1ULL << 47) | |
303 | ||
304 | /** | |
305 | * Don't put lock into the LRU list, so that it is not canceled due | |
306 | * to aging. Used by MGC locks, they are cancelled only at unmount or | |
307 | * by callback. */ | |
308 | #define LDLM_FL_NO_LRU 0x0001000000000000ULL // bit 48 | |
309 | #define ldlm_is_no_lru(_l) LDLM_TEST_FLAG(( _l), 1ULL << 48) | |
310 | #define ldlm_set_no_lru(_l) LDLM_SET_FLAG(( _l), 1ULL << 48) | |
311 | #define ldlm_clear_no_lru(_l) LDLM_CLEAR_FLAG((_l), 1ULL << 48) | |
312 | ||
313 | /** | |
314 | * Set for locks that failed and where the server has been notified. | |
315 | * | |
316 | * Protected by lock and resource locks. */ | |
317 | #define LDLM_FL_FAIL_NOTIFIED 0x0002000000000000ULL // bit 49 | |
318 | #define ldlm_is_fail_notified(_l) LDLM_TEST_FLAG(( _l), 1ULL << 49) | |
319 | #define ldlm_set_fail_notified(_l) LDLM_SET_FLAG(( _l), 1ULL << 49) | |
320 | #define ldlm_clear_fail_notified(_l) LDLM_CLEAR_FLAG((_l), 1ULL << 49) | |
321 | ||
322 | /** | |
323 | * Set for locks that were removed from class hash table and will | |
324 | * be destroyed when last reference to them is released. Set by | |
325 | * ldlm_lock_destroy_internal(). | |
326 | * | |
327 | * Protected by lock and resource locks. */ | |
328 | #define LDLM_FL_DESTROYED 0x0004000000000000ULL // bit 50 | |
329 | #define ldlm_is_destroyed(_l) LDLM_TEST_FLAG(( _l), 1ULL << 50) | |
330 | #define ldlm_set_destroyed(_l) LDLM_SET_FLAG(( _l), 1ULL << 50) | |
331 | #define ldlm_clear_destroyed(_l) LDLM_CLEAR_FLAG((_l), 1ULL << 50) | |
332 | ||
333 | /** flag whether this is a server namespace lock */ | |
334 | #define LDLM_FL_SERVER_LOCK 0x0008000000000000ULL // bit 51 | |
335 | #define ldlm_is_server_lock(_l) LDLM_TEST_FLAG(( _l), 1ULL << 51) | |
336 | #define ldlm_set_server_lock(_l) LDLM_SET_FLAG(( _l), 1ULL << 51) | |
337 | #define ldlm_clear_server_lock(_l) LDLM_CLEAR_FLAG((_l), 1ULL << 51) | |
338 | ||
339 | /** | |
340 | * It's set in lock_res_and_lock() and unset in unlock_res_and_lock(). | |
341 | * | |
342 | * NB: compared with check_res_locked(), checking this bit is cheaper. | |
343 | * Also, spin_is_locked() is deprecated for kernel code; one reason is | |
344 | * because it works only for SMP so user needs to add extra macros like | |
345 | * LASSERT_SPIN_LOCKED for uniprocessor kernels. */ | |
346 | #define LDLM_FL_RES_LOCKED 0x0010000000000000ULL // bit 52 | |
347 | #define ldlm_is_res_locked(_l) LDLM_TEST_FLAG(( _l), 1ULL << 52) | |
348 | #define ldlm_set_res_locked(_l) LDLM_SET_FLAG(( _l), 1ULL << 52) | |
349 | #define ldlm_clear_res_locked(_l) LDLM_CLEAR_FLAG((_l), 1ULL << 52) | |
350 | ||
351 | /** | |
352 | * It's set once we call ldlm_add_waiting_lock_res_locked() to start the | |
353 | * lock-timeout timer and it will never be reset. | |
354 | * | |
355 | * Protected by lock and resource locks. */ | |
356 | #define LDLM_FL_WAITED 0x0020000000000000ULL // bit 53 | |
357 | #define ldlm_is_waited(_l) LDLM_TEST_FLAG(( _l), 1ULL << 53) | |
358 | #define ldlm_set_waited(_l) LDLM_SET_FLAG(( _l), 1ULL << 53) | |
359 | #define ldlm_clear_waited(_l) LDLM_CLEAR_FLAG((_l), 1ULL << 53) | |
360 | ||
361 | /** Flag whether this is a server namespace lock. */ | |
362 | #define LDLM_FL_NS_SRV 0x0040000000000000ULL // bit 54 | |
363 | #define ldlm_is_ns_srv(_l) LDLM_TEST_FLAG(( _l), 1ULL << 54) | |
364 | #define ldlm_set_ns_srv(_l) LDLM_SET_FLAG(( _l), 1ULL << 54) | |
365 | #define ldlm_clear_ns_srv(_l) LDLM_CLEAR_FLAG((_l), 1ULL << 54) | |
366 | ||
d3a8a4e2 JX |
367 | /** Flag whether this lock can be reused. Used by exclusive open. */ |
368 | #define LDLM_FL_EXCL 0x0080000000000000ULL /* bit 55 */ | |
369 | #define ldlm_is_excl(_l) LDLM_TEST_FLAG((_l), 1ULL << 55) | |
370 | #define ldlm_set_excl(_l) LDLM_SET_FLAG((_l), 1ULL << 55) | |
371 | #define ldlm_clear_excl(_l) LDLM_CLEAR_FLAG((_l), 1ULL << 55) | |
372 | ||
f2145eae BK |
373 | /** test for ldlm_lock flag bit set */ |
374 | #define LDLM_TEST_FLAG(_l, _b) (((_l)->l_flags & (_b)) != 0) | |
375 | ||
376 | /** set a ldlm_lock flag bit */ | |
377 | #define LDLM_SET_FLAG(_l, _b) (((_l)->l_flags |= (_b)) | |
378 | ||
379 | /** clear a ldlm_lock flag bit */ | |
380 | #define LDLM_CLEAR_FLAG(_l, _b) (((_l)->l_flags &= ~(_b)) | |
381 | ||
382 | /** Mask of flags inherited from parent lock when doing intents. */ | |
383 | #define LDLM_INHERIT_FLAGS LDLM_FL_INHERIT_MASK | |
384 | ||
385 | /** Mask of Flags sent in AST lock_flags to map into the receiving lock. */ | |
386 | #define LDLM_AST_FLAGS LDLM_FL_AST_MASK | |
387 | ||
388 | /** @} subgroup */ | |
389 | /** @} group */ | |
390 | #ifdef WIRESHARK_COMPILE | |
391 | static int hf_lustre_ldlm_fl_lock_changed = -1; | |
392 | static int hf_lustre_ldlm_fl_block_granted = -1; | |
393 | static int hf_lustre_ldlm_fl_block_conv = -1; | |
394 | static int hf_lustre_ldlm_fl_block_wait = -1; | |
395 | static int hf_lustre_ldlm_fl_ast_sent = -1; | |
396 | static int hf_lustre_ldlm_fl_replay = -1; | |
397 | static int hf_lustre_ldlm_fl_intent_only = -1; | |
398 | static int hf_lustre_ldlm_fl_has_intent = -1; | |
69342b78 | 399 | static int hf_lustre_ldlm_fl_flock_deadlock = -1; |
f2145eae BK |
400 | static int hf_lustre_ldlm_fl_discard_data = -1; |
401 | static int hf_lustre_ldlm_fl_no_timeout = -1; | |
402 | static int hf_lustre_ldlm_fl_block_nowait = -1; | |
403 | static int hf_lustre_ldlm_fl_test_lock = -1; | |
404 | static int hf_lustre_ldlm_fl_cancel_on_block = -1; | |
405 | static int hf_lustre_ldlm_fl_deny_on_contention = -1; | |
406 | static int hf_lustre_ldlm_fl_ast_discard_data = -1; | |
407 | static int hf_lustre_ldlm_fl_fail_loc = -1; | |
408 | static int hf_lustre_ldlm_fl_skipped = -1; | |
409 | static int hf_lustre_ldlm_fl_cbpending = -1; | |
410 | static int hf_lustre_ldlm_fl_wait_noreproc = -1; | |
411 | static int hf_lustre_ldlm_fl_cancel = -1; | |
412 | static int hf_lustre_ldlm_fl_local_only = -1; | |
413 | static int hf_lustre_ldlm_fl_failed = -1; | |
414 | static int hf_lustre_ldlm_fl_canceling = -1; | |
415 | static int hf_lustre_ldlm_fl_local = -1; | |
416 | static int hf_lustre_ldlm_fl_lvb_ready = -1; | |
417 | static int hf_lustre_ldlm_fl_kms_ignore = -1; | |
418 | static int hf_lustre_ldlm_fl_cp_reqd = -1; | |
419 | static int hf_lustre_ldlm_fl_cleaned = -1; | |
420 | static int hf_lustre_ldlm_fl_atomic_cb = -1; | |
421 | static int hf_lustre_ldlm_fl_bl_ast = -1; | |
422 | static int hf_lustre_ldlm_fl_bl_done = -1; | |
423 | static int hf_lustre_ldlm_fl_no_lru = -1; | |
424 | static int hf_lustre_ldlm_fl_fail_notified = -1; | |
425 | static int hf_lustre_ldlm_fl_destroyed = -1; | |
426 | static int hf_lustre_ldlm_fl_server_lock = -1; | |
427 | static int hf_lustre_ldlm_fl_res_locked = -1; | |
428 | static int hf_lustre_ldlm_fl_waited = -1; | |
429 | static int hf_lustre_ldlm_fl_ns_srv = -1; | |
d3a8a4e2 | 430 | static int hf_lustre_ldlm_fl_excl = -1; |
f2145eae BK |
431 | |
432 | const value_string lustre_ldlm_flags_vals[] = { | |
d298b537 PT |
433 | {LDLM_FL_LOCK_CHANGED, "LDLM_FL_LOCK_CHANGED"}, |
434 | {LDLM_FL_BLOCK_GRANTED, "LDLM_FL_BLOCK_GRANTED"}, | |
435 | {LDLM_FL_BLOCK_CONV, "LDLM_FL_BLOCK_CONV"}, | |
436 | {LDLM_FL_BLOCK_WAIT, "LDLM_FL_BLOCK_WAIT"}, | |
437 | {LDLM_FL_AST_SENT, "LDLM_FL_AST_SENT"}, | |
438 | {LDLM_FL_REPLAY, "LDLM_FL_REPLAY"}, | |
439 | {LDLM_FL_INTENT_ONLY, "LDLM_FL_INTENT_ONLY"}, | |
440 | {LDLM_FL_HAS_INTENT, "LDLM_FL_HAS_INTENT"}, | |
69342b78 | 441 | {LDLM_FL_FLOCK_DEADLOCK, "LDLM_FL_FLOCK_DEADLOCK"}, |
d298b537 PT |
442 | {LDLM_FL_DISCARD_DATA, "LDLM_FL_DISCARD_DATA"}, |
443 | {LDLM_FL_NO_TIMEOUT, "LDLM_FL_NO_TIMEOUT"}, | |
444 | {LDLM_FL_BLOCK_NOWAIT, "LDLM_FL_BLOCK_NOWAIT"}, | |
445 | {LDLM_FL_TEST_LOCK, "LDLM_FL_TEST_LOCK"}, | |
446 | {LDLM_FL_CANCEL_ON_BLOCK, "LDLM_FL_CANCEL_ON_BLOCK"}, | |
447 | {LDLM_FL_DENY_ON_CONTENTION, "LDLM_FL_DENY_ON_CONTENTION"}, | |
448 | {LDLM_FL_AST_DISCARD_DATA, "LDLM_FL_AST_DISCARD_DATA"}, | |
449 | {LDLM_FL_FAIL_LOC, "LDLM_FL_FAIL_LOC"}, | |
450 | {LDLM_FL_SKIPPED, "LDLM_FL_SKIPPED"}, | |
451 | {LDLM_FL_CBPENDING, "LDLM_FL_CBPENDING"}, | |
452 | {LDLM_FL_WAIT_NOREPROC, "LDLM_FL_WAIT_NOREPROC"}, | |
453 | {LDLM_FL_CANCEL, "LDLM_FL_CANCEL"}, | |
454 | {LDLM_FL_LOCAL_ONLY, "LDLM_FL_LOCAL_ONLY"}, | |
455 | {LDLM_FL_FAILED, "LDLM_FL_FAILED"}, | |
456 | {LDLM_FL_CANCELING, "LDLM_FL_CANCELING"}, | |
457 | {LDLM_FL_LOCAL, "LDLM_FL_LOCAL"}, | |
458 | {LDLM_FL_LVB_READY, "LDLM_FL_LVB_READY"}, | |
459 | {LDLM_FL_KMS_IGNORE, "LDLM_FL_KMS_IGNORE"}, | |
460 | {LDLM_FL_CP_REQD, "LDLM_FL_CP_REQD"}, | |
461 | {LDLM_FL_CLEANED, "LDLM_FL_CLEANED"}, | |
462 | {LDLM_FL_ATOMIC_CB, "LDLM_FL_ATOMIC_CB"}, | |
463 | {LDLM_FL_BL_AST, "LDLM_FL_BL_AST"}, | |
464 | {LDLM_FL_BL_DONE, "LDLM_FL_BL_DONE"}, | |
465 | {LDLM_FL_NO_LRU, "LDLM_FL_NO_LRU"}, | |
466 | {LDLM_FL_FAIL_NOTIFIED, "LDLM_FL_FAIL_NOTIFIED"}, | |
467 | {LDLM_FL_DESTROYED, "LDLM_FL_DESTROYED"}, | |
468 | {LDLM_FL_SERVER_LOCK, "LDLM_FL_SERVER_LOCK"}, | |
469 | {LDLM_FL_RES_LOCKED, "LDLM_FL_RES_LOCKED"}, | |
470 | {LDLM_FL_WAITED, "LDLM_FL_WAITED"}, | |
471 | {LDLM_FL_NS_SRV, "LDLM_FL_NS_SRV"}, | |
472 | {LDLM_FL_EXCL, "LDLM_FL_EXCL"}, | |
473 | { 0, NULL } | |
f2145eae BK |
474 | }; |
475 | #endif /* WIRESHARK_COMPILE */ | |
476 | #endif /* LDLM_ALL_FLAGS_MASK */ |