1 // SPDX-License-Identifier: GPL-2.0-or-later 2 /* -*- mode: c; c-basic-offset: 8; -*- 3 * vim: noexpandtab sw=8 ts=8 sts=0: 4 * 5 * dlmast.c 6 * 7 * AST and BAST functionality for local and remote nodes 8 * 9 * Copyright (C) 2004 Oracle. All rights reserved. 10 */ 11 12 13 #include <linux/module.h> 14 #include <linux/fs.h> 15 #include <linux/types.h> 16 #include <linux/highmem.h> 17 #include <linux/init.h> 18 #include <linux/sysctl.h> 19 #include <linux/random.h> 20 #include <linux/blkdev.h> 21 #include <linux/socket.h> 22 #include <linux/inet.h> 23 #include <linux/spinlock.h> 24 25 26 #include "cluster/heartbeat.h" 27 #include "cluster/nodemanager.h" 28 #include "cluster/tcp.h" 29 30 #include "dlmapi.h" 31 #include "dlmcommon.h" 32 33 #define MLOG_MASK_PREFIX ML_DLM 34 #include "cluster/masklog.h" 35 36 static void dlm_update_lvb(struct dlm_ctxt *dlm, struct dlm_lock_resource *res, 37 struct dlm_lock *lock); 38 static int dlm_should_cancel_bast(struct dlm_ctxt *dlm, struct dlm_lock *lock); 39 40 /* Should be called as an ast gets queued to see if the new 41 * lock level will obsolete a pending bast. 42 * For example, if dlm_thread queued a bast for an EX lock that 43 * was blocking another EX, but before sending the bast the 44 * lock owner downconverted to NL, the bast is now obsolete. 45 * Only the ast should be sent. 46 * This is needed because the lock and convert paths can queue 47 * asts out-of-band (not waiting for dlm_thread) in order to 48 * allow for LKM_NOQUEUE to get immediate responses. */ 49 static int dlm_should_cancel_bast(struct dlm_ctxt *dlm, struct dlm_lock *lock) 50 { 51 assert_spin_locked(&dlm->ast_lock); 52 assert_spin_locked(&lock->spinlock); 53 54 if (lock->ml.highest_blocked == LKM_IVMODE) 55 return 0; 56 BUG_ON(lock->ml.highest_blocked == LKM_NLMODE); 57 58 if (lock->bast_pending && 59 list_empty(&lock->bast_list)) 60 /* old bast already sent, ok */ 61 return 0; 62 63 if (lock->ml.type == LKM_EXMODE) 64 /* EX blocks anything left, any bast still valid */ 65 return 0; 66 else if (lock->ml.type == LKM_NLMODE) 67 /* NL blocks nothing, no reason to send any bast, cancel it */ 68 return 1; 69 else if (lock->ml.highest_blocked != LKM_EXMODE) 70 /* PR only blocks EX */ 71 return 1; 72 73 return 0; 74 } 75 76 void __dlm_queue_ast(struct dlm_ctxt *dlm, struct dlm_lock *lock) 77 { 78 struct dlm_lock_resource *res; 79 80 BUG_ON(!dlm); 81 BUG_ON(!lock); 82 83 res = lock->lockres; 84 85 assert_spin_locked(&dlm->ast_lock); 86 87 if (!list_empty(&lock->ast_list)) { 88 mlog(ML_ERROR, "%s: res %.*s, lock %u:%llu, " 89 "AST list not empty, pending %d, newlevel %d\n", 90 dlm->name, res->lockname.len, res->lockname.name, 91 dlm_get_lock_cookie_node(be64_to_cpu(lock->ml.cookie)), 92 dlm_get_lock_cookie_seq(be64_to_cpu(lock->ml.cookie)), 93 lock->ast_pending, lock->ml.type); 94 BUG(); 95 } 96 if (lock->ast_pending) 97 mlog(0, "%s: res %.*s, lock %u:%llu, AST getting flushed\n", 98 dlm->name, res->lockname.len, res->lockname.name, 99 dlm_get_lock_cookie_node(be64_to_cpu(lock->ml.cookie)), 100 dlm_get_lock_cookie_seq(be64_to_cpu(lock->ml.cookie))); 101 102 /* putting lock on list, add a ref */ 103 dlm_lock_get(lock); 104 spin_lock(&lock->spinlock); 105 106 /* check to see if this ast obsoletes the bast */ 107 if (dlm_should_cancel_bast(dlm, lock)) { 108 mlog(0, "%s: res %.*s, lock %u:%llu, Cancelling BAST\n", 109 dlm->name, res->lockname.len, res->lockname.name, 110 dlm_get_lock_cookie_node(be64_to_cpu(lock->ml.cookie)), 111 dlm_get_lock_cookie_seq(be64_to_cpu(lock->ml.cookie))); 112 lock->bast_pending = 0; 113 list_del_init(&lock->bast_list); 114 lock->ml.highest_blocked = LKM_IVMODE; 115 /* removing lock from list, remove a ref. guaranteed 116 * this won't be the last ref because of the get above, 117 * so res->spinlock will not be taken here */ 118 dlm_lock_put(lock); 119 /* free up the reserved bast that we are cancelling. 120 * guaranteed that this will not be the last reserved 121 * ast because *both* an ast and a bast were reserved 122 * to get to this point. the res->spinlock will not be 123 * taken here */ 124 dlm_lockres_release_ast(dlm, res); 125 } 126 list_add_tail(&lock->ast_list, &dlm->pending_asts); 127 lock->ast_pending = 1; 128 spin_unlock(&lock->spinlock); 129 } 130 131 void dlm_queue_ast(struct dlm_ctxt *dlm, struct dlm_lock *lock) 132 { 133 BUG_ON(!dlm); 134 BUG_ON(!lock); 135 136 spin_lock(&dlm->ast_lock); 137 __dlm_queue_ast(dlm, lock); 138 spin_unlock(&dlm->ast_lock); 139 } 140 141 142 void __dlm_queue_bast(struct dlm_ctxt *dlm, struct dlm_lock *lock) 143 { 144 struct dlm_lock_resource *res; 145 146 BUG_ON(!dlm); 147 BUG_ON(!lock); 148 149 assert_spin_locked(&dlm->ast_lock); 150 151 res = lock->lockres; 152 153 BUG_ON(!list_empty(&lock->bast_list)); 154 if (lock->bast_pending) 155 mlog(0, "%s: res %.*s, lock %u:%llu, BAST getting flushed\n", 156 dlm->name, res->lockname.len, res->lockname.name, 157 dlm_get_lock_cookie_node(be64_to_cpu(lock->ml.cookie)), 158 dlm_get_lock_cookie_seq(be64_to_cpu(lock->ml.cookie))); 159 160 /* putting lock on list, add a ref */ 161 dlm_lock_get(lock); 162 spin_lock(&lock->spinlock); 163 list_add_tail(&lock->bast_list, &dlm->pending_basts); 164 lock->bast_pending = 1; 165 spin_unlock(&lock->spinlock); 166 } 167 168 void dlm_queue_bast(struct dlm_ctxt *dlm, struct dlm_lock *lock) 169 { 170 BUG_ON(!dlm); 171 BUG_ON(!lock); 172 173 spin_lock(&dlm->ast_lock); 174 __dlm_queue_bast(dlm, lock); 175 spin_unlock(&dlm->ast_lock); 176 } 177 178 static void dlm_update_lvb(struct dlm_ctxt *dlm, struct dlm_lock_resource *res, 179 struct dlm_lock *lock) 180 { 181 struct dlm_lockstatus *lksb = lock->lksb; 182 BUG_ON(!lksb); 183 184 /* only updates if this node masters the lockres */ 185 spin_lock(&res->spinlock); 186 if (res->owner == dlm->node_num) { 187 /* check the lksb flags for the direction */ 188 if (lksb->flags & DLM_LKSB_GET_LVB) { 189 mlog(0, "getting lvb from lockres for %s node\n", 190 lock->ml.node == dlm->node_num ? "master" : 191 "remote"); 192 memcpy(lksb->lvb, res->lvb, DLM_LVB_LEN); 193 } 194 /* Do nothing for lvb put requests - they should be done in 195 * place when the lock is downconverted - otherwise we risk 196 * racing gets and puts which could result in old lvb data 197 * being propagated. We leave the put flag set and clear it 198 * here. In the future we might want to clear it at the time 199 * the put is actually done. 200 */ 201 } 202 spin_unlock(&res->spinlock); 203 204 /* reset any lvb flags on the lksb */ 205 lksb->flags &= ~(DLM_LKSB_PUT_LVB|DLM_LKSB_GET_LVB); 206 } 207 208 void dlm_do_local_ast(struct dlm_ctxt *dlm, struct dlm_lock_resource *res, 209 struct dlm_lock *lock) 210 { 211 dlm_astlockfunc_t *fn; 212 213 mlog(0, "%s: res %.*s, lock %u:%llu, Local AST\n", dlm->name, 214 res->lockname.len, res->lockname.name, 215 dlm_get_lock_cookie_node(be64_to_cpu(lock->ml.cookie)), 216 dlm_get_lock_cookie_seq(be64_to_cpu(lock->ml.cookie))); 217 218 fn = lock->ast; 219 BUG_ON(lock->ml.node != dlm->node_num); 220 221 dlm_update_lvb(dlm, res, lock); 222 (*fn)(lock->astdata); 223 } 224 225 226 int dlm_do_remote_ast(struct dlm_ctxt *dlm, struct dlm_lock_resource *res, 227 struct dlm_lock *lock) 228 { 229 int ret; 230 struct dlm_lockstatus *lksb; 231 int lksbflags; 232 233 mlog(0, "%s: res %.*s, lock %u:%llu, Remote AST\n", dlm->name, 234 res->lockname.len, res->lockname.name, 235 dlm_get_lock_cookie_node(be64_to_cpu(lock->ml.cookie)), 236 dlm_get_lock_cookie_seq(be64_to_cpu(lock->ml.cookie))); 237 238 lksb = lock->lksb; 239 BUG_ON(lock->ml.node == dlm->node_num); 240 241 lksbflags = lksb->flags; 242 dlm_update_lvb(dlm, res, lock); 243 244 /* lock request came from another node 245 * go do the ast over there */ 246 ret = dlm_send_proxy_ast(dlm, res, lock, lksbflags); 247 return ret; 248 } 249 250 void dlm_do_local_bast(struct dlm_ctxt *dlm, struct dlm_lock_resource *res, 251 struct dlm_lock *lock, int blocked_type) 252 { 253 dlm_bastlockfunc_t *fn = lock->bast; 254 255 BUG_ON(lock->ml.node != dlm->node_num); 256 257 mlog(0, "%s: res %.*s, lock %u:%llu, Local BAST, blocked %d\n", 258 dlm->name, res->lockname.len, res->lockname.name, 259 dlm_get_lock_cookie_node(be64_to_cpu(lock->ml.cookie)), 260 dlm_get_lock_cookie_seq(be64_to_cpu(lock->ml.cookie)), 261 blocked_type); 262 263 (*fn)(lock->astdata, blocked_type); 264 } 265 266 267 268 int dlm_proxy_ast_handler(struct o2net_msg *msg, u32 len, void *data, 269 void **ret_data) 270 { 271 int ret; 272 unsigned int locklen; 273 struct dlm_ctxt *dlm = data; 274 struct dlm_lock_resource *res = NULL; 275 struct dlm_lock *lock = NULL; 276 struct dlm_proxy_ast *past = (struct dlm_proxy_ast *) msg->buf; 277 char *name; 278 struct list_head *head = NULL; 279 __be64 cookie; 280 u32 flags; 281 u8 node; 282 283 if (!dlm_grab(dlm)) { 284 dlm_error(DLM_REJECTED); 285 return DLM_REJECTED; 286 } 287 288 mlog_bug_on_msg(!dlm_domain_fully_joined(dlm), 289 "Domain %s not fully joined!\n", dlm->name); 290 291 name = past->name; 292 locklen = past->namelen; 293 cookie = past->cookie; 294 flags = be32_to_cpu(past->flags); 295 node = past->node_idx; 296 297 if (locklen > DLM_LOCKID_NAME_MAX) { 298 ret = DLM_IVBUFLEN; 299 mlog(ML_ERROR, "Invalid name length (%d) in proxy ast " 300 "handler!\n", locklen); 301 goto leave; 302 } 303 304 if ((flags & (LKM_PUT_LVB|LKM_GET_LVB)) == 305 (LKM_PUT_LVB|LKM_GET_LVB)) { 306 mlog(ML_ERROR, "Both PUT and GET lvb specified, (0x%x)\n", 307 flags); 308 ret = DLM_BADARGS; 309 goto leave; 310 } 311 312 mlog(0, "lvb: %s\n", flags & LKM_PUT_LVB ? "put lvb" : 313 (flags & LKM_GET_LVB ? "get lvb" : "none")); 314 315 mlog(0, "type=%d, blocked_type=%d\n", past->type, past->blocked_type); 316 317 if (past->type != DLM_AST && 318 past->type != DLM_BAST) { 319 mlog(ML_ERROR, "Unknown ast type! %d, cookie=%u:%llu" 320 "name=%.*s, node=%u\n", past->type, 321 dlm_get_lock_cookie_node(be64_to_cpu(cookie)), 322 dlm_get_lock_cookie_seq(be64_to_cpu(cookie)), 323 locklen, name, node); 324 ret = DLM_IVLOCKID; 325 goto leave; 326 } 327 328 res = dlm_lookup_lockres(dlm, name, locklen); 329 if (!res) { 330 mlog(0, "Got %sast for unknown lockres! cookie=%u:%llu, " 331 "name=%.*s, node=%u\n", (past->type == DLM_AST ? "" : "b"), 332 dlm_get_lock_cookie_node(be64_to_cpu(cookie)), 333 dlm_get_lock_cookie_seq(be64_to_cpu(cookie)), 334 locklen, name, node); 335 ret = DLM_IVLOCKID; 336 goto leave; 337 } 338 339 /* cannot get a proxy ast message if this node owns it */ 340 BUG_ON(res->owner == dlm->node_num); 341 342 mlog(0, "%s: res %.*s\n", dlm->name, res->lockname.len, 343 res->lockname.name); 344 345 spin_lock(&res->spinlock); 346 if (res->state & DLM_LOCK_RES_RECOVERING) { 347 mlog(0, "Responding with DLM_RECOVERING!\n"); 348 ret = DLM_RECOVERING; 349 goto unlock_out; 350 } 351 if (res->state & DLM_LOCK_RES_MIGRATING) { 352 mlog(0, "Responding with DLM_MIGRATING!\n"); 353 ret = DLM_MIGRATING; 354 goto unlock_out; 355 } 356 /* try convert queue for both ast/bast */ 357 head = &res->converting; 358 lock = NULL; 359 list_for_each_entry(lock, head, list) { 360 if (lock->ml.cookie == cookie) 361 goto do_ast; 362 } 363 364 /* if not on convert, try blocked for ast, granted for bast */ 365 if (past->type == DLM_AST) 366 head = &res->blocked; 367 else 368 head = &res->granted; 369 370 list_for_each_entry(lock, head, list) { 371 /* if lock is found but unlock is pending ignore the bast */ 372 if (lock->ml.cookie == cookie) { 373 if (lock->unlock_pending) 374 break; 375 goto do_ast; 376 } 377 } 378 379 mlog(0, "Got %sast for unknown lock! cookie=%u:%llu, name=%.*s, " 380 "node=%u\n", past->type == DLM_AST ? "" : "b", 381 dlm_get_lock_cookie_node(be64_to_cpu(cookie)), 382 dlm_get_lock_cookie_seq(be64_to_cpu(cookie)), 383 locklen, name, node); 384 385 ret = DLM_NORMAL; 386 unlock_out: 387 spin_unlock(&res->spinlock); 388 goto leave; 389 390 do_ast: 391 ret = DLM_NORMAL; 392 if (past->type == DLM_AST) { 393 /* do not alter lock refcount. switching lists. */ 394 list_move_tail(&lock->list, &res->granted); 395 mlog(0, "%s: res %.*s, lock %u:%llu, Granted type %d => %d\n", 396 dlm->name, res->lockname.len, res->lockname.name, 397 dlm_get_lock_cookie_node(be64_to_cpu(cookie)), 398 dlm_get_lock_cookie_seq(be64_to_cpu(cookie)), 399 lock->ml.type, lock->ml.convert_type); 400 401 if (lock->ml.convert_type != LKM_IVMODE) { 402 lock->ml.type = lock->ml.convert_type; 403 lock->ml.convert_type = LKM_IVMODE; 404 } else { 405 // should already be there.... 406 } 407 408 lock->lksb->status = DLM_NORMAL; 409 410 /* if we requested the lvb, fetch it into our lksb now */ 411 if (flags & LKM_GET_LVB) { 412 BUG_ON(!(lock->lksb->flags & DLM_LKSB_GET_LVB)); 413 memcpy(lock->lksb->lvb, past->lvb, DLM_LVB_LEN); 414 } 415 } 416 spin_unlock(&res->spinlock); 417 418 if (past->type == DLM_AST) 419 dlm_do_local_ast(dlm, res, lock); 420 else 421 dlm_do_local_bast(dlm, res, lock, past->blocked_type); 422 423 leave: 424 if (res) 425 dlm_lockres_put(res); 426 427 dlm_put(dlm); 428 return ret; 429 } 430 431 432 433 int dlm_send_proxy_ast_msg(struct dlm_ctxt *dlm, struct dlm_lock_resource *res, 434 struct dlm_lock *lock, int msg_type, 435 int blocked_type, int flags) 436 { 437 int ret = 0; 438 struct dlm_proxy_ast past; 439 struct kvec vec[2]; 440 size_t veclen = 1; 441 int status; 442 443 mlog(0, "%s: res %.*s, to %u, type %d, blocked_type %d\n", dlm->name, 444 res->lockname.len, res->lockname.name, lock->ml.node, msg_type, 445 blocked_type); 446 447 memset(&past, 0, sizeof(struct dlm_proxy_ast)); 448 past.node_idx = dlm->node_num; 449 past.type = msg_type; 450 past.blocked_type = blocked_type; 451 past.namelen = res->lockname.len; 452 memcpy(past.name, res->lockname.name, past.namelen); 453 past.cookie = lock->ml.cookie; 454 455 vec[0].iov_len = sizeof(struct dlm_proxy_ast); 456 vec[0].iov_base = &past; 457 if (flags & DLM_LKSB_GET_LVB) { 458 be32_add_cpu(&past.flags, LKM_GET_LVB); 459 vec[1].iov_len = DLM_LVB_LEN; 460 vec[1].iov_base = lock->lksb->lvb; 461 veclen++; 462 } 463 464 ret = o2net_send_message_vec(DLM_PROXY_AST_MSG, dlm->key, vec, veclen, 465 lock->ml.node, &status); 466 if (ret < 0) 467 mlog(ML_ERROR, "%s: res %.*s, error %d send AST to node %u\n", 468 dlm->name, res->lockname.len, res->lockname.name, ret, 469 lock->ml.node); 470 else { 471 if (status == DLM_RECOVERING) { 472 mlog(ML_ERROR, "sent AST to node %u, it thinks this " 473 "node is dead!\n", lock->ml.node); 474 BUG(); 475 } else if (status == DLM_MIGRATING) { 476 mlog(ML_ERROR, "sent AST to node %u, it returned " 477 "DLM_MIGRATING!\n", lock->ml.node); 478 BUG(); 479 } else if (status != DLM_NORMAL && status != DLM_IVLOCKID) { 480 mlog(ML_ERROR, "AST to node %u returned %d!\n", 481 lock->ml.node, status); 482 /* ignore it */ 483 } 484 ret = 0; 485 } 486 return ret; 487 } 488