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 */ 38 #define LDLM_FL_ALL_FLAGS_MASK 0x00FFFFFFC08F932FULL 39 40 /** l_flags bits marked as "ast" bits */ 41 #define LDLM_FL_AST_MASK 0x0000000080008000ULL 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 */ 56 #define LDLM_FL_LOCAL_ONLY_MASK 0x00FFFFFF00000000ULL 57 58 /** l_flags bits marked as "on_wire" bits */ 59 #define LDLM_FL_ON_WIRE_MASK 0x00000000C08F932FULL 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 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 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 /** 150 * Immediately cancel such locks when they block some other locks. Send 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 251 * has finished the part of its cancellation that performs write back on its 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 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 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; 399 static int hf_lustre_ldlm_fl_flock_deadlock = -1; 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; 430 static int hf_lustre_ldlm_fl_excl = -1; 431 432 const value_string lustre_ldlm_flags_vals[] = { 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"}, 441 {LDLM_FL_FLOCK_DEADLOCK, "LDLM_FL_FLOCK_DEADLOCK"}, 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 } 474 }; 475 #endif /* WIRESHARK_COMPILE */ 476 #endif /* LDLM_ALL_FLAGS_MASK */ 477