Loading...
1// SPDX-License-Identifier: GPL-2.0-only
2/******************************************************************************
3*******************************************************************************
4**
5** Copyright (C) 2005-2010 Red Hat, Inc. All rights reserved.
6**
7**
8*******************************************************************************
9******************************************************************************/
10
11/* Central locking logic has four stages:
12
13 dlm_lock()
14 dlm_unlock()
15
16 request_lock(ls, lkb)
17 convert_lock(ls, lkb)
18 unlock_lock(ls, lkb)
19 cancel_lock(ls, lkb)
20
21 _request_lock(r, lkb)
22 _convert_lock(r, lkb)
23 _unlock_lock(r, lkb)
24 _cancel_lock(r, lkb)
25
26 do_request(r, lkb)
27 do_convert(r, lkb)
28 do_unlock(r, lkb)
29 do_cancel(r, lkb)
30
31 Stage 1 (lock, unlock) is mainly about checking input args and
32 splitting into one of the four main operations:
33
34 dlm_lock = request_lock
35 dlm_lock+CONVERT = convert_lock
36 dlm_unlock = unlock_lock
37 dlm_unlock+CANCEL = cancel_lock
38
39 Stage 2, xxxx_lock(), just finds and locks the relevant rsb which is
40 provided to the next stage.
41
42 Stage 3, _xxxx_lock(), determines if the operation is local or remote.
43 When remote, it calls send_xxxx(), when local it calls do_xxxx().
44
45 Stage 4, do_xxxx(), is the guts of the operation. It manipulates the
46 given rsb and lkb and queues callbacks.
47
48 For remote operations, send_xxxx() results in the corresponding do_xxxx()
49 function being executed on the remote node. The connecting send/receive
50 calls on local (L) and remote (R) nodes:
51
52 L: send_xxxx() -> R: receive_xxxx()
53 R: do_xxxx()
54 L: receive_xxxx_reply() <- R: send_xxxx_reply()
55*/
56#include <linux/types.h>
57#include <linux/rbtree.h>
58#include <linux/slab.h>
59#include "dlm_internal.h"
60#include <linux/dlm_device.h>
61#include "memory.h"
62#include "midcomms.h"
63#include "requestqueue.h"
64#include "util.h"
65#include "dir.h"
66#include "member.h"
67#include "lockspace.h"
68#include "ast.h"
69#include "lock.h"
70#include "rcom.h"
71#include "recover.h"
72#include "lvb_table.h"
73#include "user.h"
74#include "config.h"
75
76static int send_request(struct dlm_rsb *r, struct dlm_lkb *lkb);
77static int send_convert(struct dlm_rsb *r, struct dlm_lkb *lkb);
78static int send_unlock(struct dlm_rsb *r, struct dlm_lkb *lkb);
79static int send_cancel(struct dlm_rsb *r, struct dlm_lkb *lkb);
80static int send_grant(struct dlm_rsb *r, struct dlm_lkb *lkb);
81static int send_bast(struct dlm_rsb *r, struct dlm_lkb *lkb, int mode);
82static int send_lookup(struct dlm_rsb *r, struct dlm_lkb *lkb);
83static int send_remove(struct dlm_rsb *r);
84static int _request_lock(struct dlm_rsb *r, struct dlm_lkb *lkb);
85static int _cancel_lock(struct dlm_rsb *r, struct dlm_lkb *lkb);
86static void __receive_convert_reply(struct dlm_rsb *r, struct dlm_lkb *lkb,
87 struct dlm_message *ms);
88static int receive_extralen(struct dlm_message *ms);
89static void do_purge(struct dlm_ls *ls, int nodeid, int pid);
90static void del_timeout(struct dlm_lkb *lkb);
91static void toss_rsb(struct kref *kref);
92
93/*
94 * Lock compatibilty matrix - thanks Steve
95 * UN = Unlocked state. Not really a state, used as a flag
96 * PD = Padding. Used to make the matrix a nice power of two in size
97 * Other states are the same as the VMS DLM.
98 * Usage: matrix[grmode+1][rqmode+1] (although m[rq+1][gr+1] is the same)
99 */
100
101static const int __dlm_compat_matrix[8][8] = {
102 /* UN NL CR CW PR PW EX PD */
103 {1, 1, 1, 1, 1, 1, 1, 0}, /* UN */
104 {1, 1, 1, 1, 1, 1, 1, 0}, /* NL */
105 {1, 1, 1, 1, 1, 1, 0, 0}, /* CR */
106 {1, 1, 1, 1, 0, 0, 0, 0}, /* CW */
107 {1, 1, 1, 0, 1, 0, 0, 0}, /* PR */
108 {1, 1, 1, 0, 0, 0, 0, 0}, /* PW */
109 {1, 1, 0, 0, 0, 0, 0, 0}, /* EX */
110 {0, 0, 0, 0, 0, 0, 0, 0} /* PD */
111};
112
113/*
114 * This defines the direction of transfer of LVB data.
115 * Granted mode is the row; requested mode is the column.
116 * Usage: matrix[grmode+1][rqmode+1]
117 * 1 = LVB is returned to the caller
118 * 0 = LVB is written to the resource
119 * -1 = nothing happens to the LVB
120 */
121
122const int dlm_lvb_operations[8][8] = {
123 /* UN NL CR CW PR PW EX PD*/
124 { -1, 1, 1, 1, 1, 1, 1, -1 }, /* UN */
125 { -1, 1, 1, 1, 1, 1, 1, 0 }, /* NL */
126 { -1, -1, 1, 1, 1, 1, 1, 0 }, /* CR */
127 { -1, -1, -1, 1, 1, 1, 1, 0 }, /* CW */
128 { -1, -1, -1, -1, 1, 1, 1, 0 }, /* PR */
129 { -1, 0, 0, 0, 0, 0, 1, 0 }, /* PW */
130 { -1, 0, 0, 0, 0, 0, 0, 0 }, /* EX */
131 { -1, 0, 0, 0, 0, 0, 0, 0 } /* PD */
132};
133
134#define modes_compat(gr, rq) \
135 __dlm_compat_matrix[(gr)->lkb_grmode + 1][(rq)->lkb_rqmode + 1]
136
137int dlm_modes_compat(int mode1, int mode2)
138{
139 return __dlm_compat_matrix[mode1 + 1][mode2 + 1];
140}
141
142/*
143 * Compatibility matrix for conversions with QUECVT set.
144 * Granted mode is the row; requested mode is the column.
145 * Usage: matrix[grmode+1][rqmode+1]
146 */
147
148static const int __quecvt_compat_matrix[8][8] = {
149 /* UN NL CR CW PR PW EX PD */
150 {0, 0, 0, 0, 0, 0, 0, 0}, /* UN */
151 {0, 0, 1, 1, 1, 1, 1, 0}, /* NL */
152 {0, 0, 0, 1, 1, 1, 1, 0}, /* CR */
153 {0, 0, 0, 0, 1, 1, 1, 0}, /* CW */
154 {0, 0, 0, 1, 0, 1, 1, 0}, /* PR */
155 {0, 0, 0, 0, 0, 0, 1, 0}, /* PW */
156 {0, 0, 0, 0, 0, 0, 0, 0}, /* EX */
157 {0, 0, 0, 0, 0, 0, 0, 0} /* PD */
158};
159
160void dlm_print_lkb(struct dlm_lkb *lkb)
161{
162 printk(KERN_ERR "lkb: nodeid %d id %x remid %x exflags %x flags %x "
163 "sts %d rq %d gr %d wait_type %d wait_nodeid %d seq %llu\n",
164 lkb->lkb_nodeid, lkb->lkb_id, lkb->lkb_remid, lkb->lkb_exflags,
165 lkb->lkb_flags, lkb->lkb_status, lkb->lkb_rqmode,
166 lkb->lkb_grmode, lkb->lkb_wait_type, lkb->lkb_wait_nodeid,
167 (unsigned long long)lkb->lkb_recover_seq);
168}
169
170static void dlm_print_rsb(struct dlm_rsb *r)
171{
172 printk(KERN_ERR "rsb: nodeid %d master %d dir %d flags %lx first %x "
173 "rlc %d name %s\n",
174 r->res_nodeid, r->res_master_nodeid, r->res_dir_nodeid,
175 r->res_flags, r->res_first_lkid, r->res_recover_locks_count,
176 r->res_name);
177}
178
179void dlm_dump_rsb(struct dlm_rsb *r)
180{
181 struct dlm_lkb *lkb;
182
183 dlm_print_rsb(r);
184
185 printk(KERN_ERR "rsb: root_list empty %d recover_list empty %d\n",
186 list_empty(&r->res_root_list), list_empty(&r->res_recover_list));
187 printk(KERN_ERR "rsb lookup list\n");
188 list_for_each_entry(lkb, &r->res_lookup, lkb_rsb_lookup)
189 dlm_print_lkb(lkb);
190 printk(KERN_ERR "rsb grant queue:\n");
191 list_for_each_entry(lkb, &r->res_grantqueue, lkb_statequeue)
192 dlm_print_lkb(lkb);
193 printk(KERN_ERR "rsb convert queue:\n");
194 list_for_each_entry(lkb, &r->res_convertqueue, lkb_statequeue)
195 dlm_print_lkb(lkb);
196 printk(KERN_ERR "rsb wait queue:\n");
197 list_for_each_entry(lkb, &r->res_waitqueue, lkb_statequeue)
198 dlm_print_lkb(lkb);
199}
200
201/* Threads cannot use the lockspace while it's being recovered */
202
203static inline void dlm_lock_recovery(struct dlm_ls *ls)
204{
205 down_read(&ls->ls_in_recovery);
206}
207
208void dlm_unlock_recovery(struct dlm_ls *ls)
209{
210 up_read(&ls->ls_in_recovery);
211}
212
213int dlm_lock_recovery_try(struct dlm_ls *ls)
214{
215 return down_read_trylock(&ls->ls_in_recovery);
216}
217
218static inline int can_be_queued(struct dlm_lkb *lkb)
219{
220 return !(lkb->lkb_exflags & DLM_LKF_NOQUEUE);
221}
222
223static inline int force_blocking_asts(struct dlm_lkb *lkb)
224{
225 return (lkb->lkb_exflags & DLM_LKF_NOQUEUEBAST);
226}
227
228static inline int is_demoted(struct dlm_lkb *lkb)
229{
230 return (lkb->lkb_sbflags & DLM_SBF_DEMOTED);
231}
232
233static inline int is_altmode(struct dlm_lkb *lkb)
234{
235 return (lkb->lkb_sbflags & DLM_SBF_ALTMODE);
236}
237
238static inline int is_granted(struct dlm_lkb *lkb)
239{
240 return (lkb->lkb_status == DLM_LKSTS_GRANTED);
241}
242
243static inline int is_remote(struct dlm_rsb *r)
244{
245 DLM_ASSERT(r->res_nodeid >= 0, dlm_print_rsb(r););
246 return !!r->res_nodeid;
247}
248
249static inline int is_process_copy(struct dlm_lkb *lkb)
250{
251 return (lkb->lkb_nodeid && !(lkb->lkb_flags & DLM_IFL_MSTCPY));
252}
253
254static inline int is_master_copy(struct dlm_lkb *lkb)
255{
256 return (lkb->lkb_flags & DLM_IFL_MSTCPY) ? 1 : 0;
257}
258
259static inline int middle_conversion(struct dlm_lkb *lkb)
260{
261 if ((lkb->lkb_grmode==DLM_LOCK_PR && lkb->lkb_rqmode==DLM_LOCK_CW) ||
262 (lkb->lkb_rqmode==DLM_LOCK_PR && lkb->lkb_grmode==DLM_LOCK_CW))
263 return 1;
264 return 0;
265}
266
267static inline int down_conversion(struct dlm_lkb *lkb)
268{
269 return (!middle_conversion(lkb) && lkb->lkb_rqmode < lkb->lkb_grmode);
270}
271
272static inline int is_overlap_unlock(struct dlm_lkb *lkb)
273{
274 return lkb->lkb_flags & DLM_IFL_OVERLAP_UNLOCK;
275}
276
277static inline int is_overlap_cancel(struct dlm_lkb *lkb)
278{
279 return lkb->lkb_flags & DLM_IFL_OVERLAP_CANCEL;
280}
281
282static inline int is_overlap(struct dlm_lkb *lkb)
283{
284 return (lkb->lkb_flags & (DLM_IFL_OVERLAP_UNLOCK |
285 DLM_IFL_OVERLAP_CANCEL));
286}
287
288static void queue_cast(struct dlm_rsb *r, struct dlm_lkb *lkb, int rv)
289{
290 if (is_master_copy(lkb))
291 return;
292
293 del_timeout(lkb);
294
295 DLM_ASSERT(lkb->lkb_lksb, dlm_print_lkb(lkb););
296
297 /* if the operation was a cancel, then return -DLM_ECANCEL, if a
298 timeout caused the cancel then return -ETIMEDOUT */
299 if (rv == -DLM_ECANCEL && (lkb->lkb_flags & DLM_IFL_TIMEOUT_CANCEL)) {
300 lkb->lkb_flags &= ~DLM_IFL_TIMEOUT_CANCEL;
301 rv = -ETIMEDOUT;
302 }
303
304 if (rv == -DLM_ECANCEL && (lkb->lkb_flags & DLM_IFL_DEADLOCK_CANCEL)) {
305 lkb->lkb_flags &= ~DLM_IFL_DEADLOCK_CANCEL;
306 rv = -EDEADLK;
307 }
308
309 dlm_add_cb(lkb, DLM_CB_CAST, lkb->lkb_grmode, rv, lkb->lkb_sbflags);
310}
311
312static inline void queue_cast_overlap(struct dlm_rsb *r, struct dlm_lkb *lkb)
313{
314 queue_cast(r, lkb,
315 is_overlap_unlock(lkb) ? -DLM_EUNLOCK : -DLM_ECANCEL);
316}
317
318static void queue_bast(struct dlm_rsb *r, struct dlm_lkb *lkb, int rqmode)
319{
320 if (is_master_copy(lkb)) {
321 send_bast(r, lkb, rqmode);
322 } else {
323 dlm_add_cb(lkb, DLM_CB_BAST, rqmode, 0, 0);
324 }
325}
326
327/*
328 * Basic operations on rsb's and lkb's
329 */
330
331/* This is only called to add a reference when the code already holds
332 a valid reference to the rsb, so there's no need for locking. */
333
334static inline void hold_rsb(struct dlm_rsb *r)
335{
336 kref_get(&r->res_ref);
337}
338
339void dlm_hold_rsb(struct dlm_rsb *r)
340{
341 hold_rsb(r);
342}
343
344/* When all references to the rsb are gone it's transferred to
345 the tossed list for later disposal. */
346
347static void put_rsb(struct dlm_rsb *r)
348{
349 struct dlm_ls *ls = r->res_ls;
350 uint32_t bucket = r->res_bucket;
351
352 spin_lock(&ls->ls_rsbtbl[bucket].lock);
353 kref_put(&r->res_ref, toss_rsb);
354 spin_unlock(&ls->ls_rsbtbl[bucket].lock);
355}
356
357void dlm_put_rsb(struct dlm_rsb *r)
358{
359 put_rsb(r);
360}
361
362static int pre_rsb_struct(struct dlm_ls *ls)
363{
364 struct dlm_rsb *r1, *r2;
365 int count = 0;
366
367 spin_lock(&ls->ls_new_rsb_spin);
368 if (ls->ls_new_rsb_count > dlm_config.ci_new_rsb_count / 2) {
369 spin_unlock(&ls->ls_new_rsb_spin);
370 return 0;
371 }
372 spin_unlock(&ls->ls_new_rsb_spin);
373
374 r1 = dlm_allocate_rsb(ls);
375 r2 = dlm_allocate_rsb(ls);
376
377 spin_lock(&ls->ls_new_rsb_spin);
378 if (r1) {
379 list_add(&r1->res_hashchain, &ls->ls_new_rsb);
380 ls->ls_new_rsb_count++;
381 }
382 if (r2) {
383 list_add(&r2->res_hashchain, &ls->ls_new_rsb);
384 ls->ls_new_rsb_count++;
385 }
386 count = ls->ls_new_rsb_count;
387 spin_unlock(&ls->ls_new_rsb_spin);
388
389 if (!count)
390 return -ENOMEM;
391 return 0;
392}
393
394/* If ls->ls_new_rsb is empty, return -EAGAIN, so the caller can
395 unlock any spinlocks, go back and call pre_rsb_struct again.
396 Otherwise, take an rsb off the list and return it. */
397
398static int get_rsb_struct(struct dlm_ls *ls, char *name, int len,
399 struct dlm_rsb **r_ret)
400{
401 struct dlm_rsb *r;
402 int count;
403
404 spin_lock(&ls->ls_new_rsb_spin);
405 if (list_empty(&ls->ls_new_rsb)) {
406 count = ls->ls_new_rsb_count;
407 spin_unlock(&ls->ls_new_rsb_spin);
408 log_debug(ls, "find_rsb retry %d %d %s",
409 count, dlm_config.ci_new_rsb_count, name);
410 return -EAGAIN;
411 }
412
413 r = list_first_entry(&ls->ls_new_rsb, struct dlm_rsb, res_hashchain);
414 list_del(&r->res_hashchain);
415 /* Convert the empty list_head to a NULL rb_node for tree usage: */
416 memset(&r->res_hashnode, 0, sizeof(struct rb_node));
417 ls->ls_new_rsb_count--;
418 spin_unlock(&ls->ls_new_rsb_spin);
419
420 r->res_ls = ls;
421 r->res_length = len;
422 memcpy(r->res_name, name, len);
423 mutex_init(&r->res_mutex);
424
425 INIT_LIST_HEAD(&r->res_lookup);
426 INIT_LIST_HEAD(&r->res_grantqueue);
427 INIT_LIST_HEAD(&r->res_convertqueue);
428 INIT_LIST_HEAD(&r->res_waitqueue);
429 INIT_LIST_HEAD(&r->res_root_list);
430 INIT_LIST_HEAD(&r->res_recover_list);
431
432 *r_ret = r;
433 return 0;
434}
435
436static int rsb_cmp(struct dlm_rsb *r, const char *name, int nlen)
437{
438 char maxname[DLM_RESNAME_MAXLEN];
439
440 memset(maxname, 0, DLM_RESNAME_MAXLEN);
441 memcpy(maxname, name, nlen);
442 return memcmp(r->res_name, maxname, DLM_RESNAME_MAXLEN);
443}
444
445int dlm_search_rsb_tree(struct rb_root *tree, char *name, int len,
446 struct dlm_rsb **r_ret)
447{
448 struct rb_node *node = tree->rb_node;
449 struct dlm_rsb *r;
450 int rc;
451
452 while (node) {
453 r = rb_entry(node, struct dlm_rsb, res_hashnode);
454 rc = rsb_cmp(r, name, len);
455 if (rc < 0)
456 node = node->rb_left;
457 else if (rc > 0)
458 node = node->rb_right;
459 else
460 goto found;
461 }
462 *r_ret = NULL;
463 return -EBADR;
464
465 found:
466 *r_ret = r;
467 return 0;
468}
469
470static int rsb_insert(struct dlm_rsb *rsb, struct rb_root *tree)
471{
472 struct rb_node **newn = &tree->rb_node;
473 struct rb_node *parent = NULL;
474 int rc;
475
476 while (*newn) {
477 struct dlm_rsb *cur = rb_entry(*newn, struct dlm_rsb,
478 res_hashnode);
479
480 parent = *newn;
481 rc = rsb_cmp(cur, rsb->res_name, rsb->res_length);
482 if (rc < 0)
483 newn = &parent->rb_left;
484 else if (rc > 0)
485 newn = &parent->rb_right;
486 else {
487 log_print("rsb_insert match");
488 dlm_dump_rsb(rsb);
489 dlm_dump_rsb(cur);
490 return -EEXIST;
491 }
492 }
493
494 rb_link_node(&rsb->res_hashnode, parent, newn);
495 rb_insert_color(&rsb->res_hashnode, tree);
496 return 0;
497}
498
499/*
500 * Find rsb in rsbtbl and potentially create/add one
501 *
502 * Delaying the release of rsb's has a similar benefit to applications keeping
503 * NL locks on an rsb, but without the guarantee that the cached master value
504 * will still be valid when the rsb is reused. Apps aren't always smart enough
505 * to keep NL locks on an rsb that they may lock again shortly; this can lead
506 * to excessive master lookups and removals if we don't delay the release.
507 *
508 * Searching for an rsb means looking through both the normal list and toss
509 * list. When found on the toss list the rsb is moved to the normal list with
510 * ref count of 1; when found on normal list the ref count is incremented.
511 *
512 * rsb's on the keep list are being used locally and refcounted.
513 * rsb's on the toss list are not being used locally, and are not refcounted.
514 *
515 * The toss list rsb's were either
516 * - previously used locally but not any more (were on keep list, then
517 * moved to toss list when last refcount dropped)
518 * - created and put on toss list as a directory record for a lookup
519 * (we are the dir node for the res, but are not using the res right now,
520 * but some other node is)
521 *
522 * The purpose of find_rsb() is to return a refcounted rsb for local use.
523 * So, if the given rsb is on the toss list, it is moved to the keep list
524 * before being returned.
525 *
526 * toss_rsb() happens when all local usage of the rsb is done, i.e. no
527 * more refcounts exist, so the rsb is moved from the keep list to the
528 * toss list.
529 *
530 * rsb's on both keep and toss lists are used for doing a name to master
531 * lookups. rsb's that are in use locally (and being refcounted) are on
532 * the keep list, rsb's that are not in use locally (not refcounted) and
533 * only exist for name/master lookups are on the toss list.
534 *
535 * rsb's on the toss list who's dir_nodeid is not local can have stale
536 * name/master mappings. So, remote requests on such rsb's can potentially
537 * return with an error, which means the mapping is stale and needs to
538 * be updated with a new lookup. (The idea behind MASTER UNCERTAIN and
539 * first_lkid is to keep only a single outstanding request on an rsb
540 * while that rsb has a potentially stale master.)
541 */
542
543static int find_rsb_dir(struct dlm_ls *ls, char *name, int len,
544 uint32_t hash, uint32_t b,
545 int dir_nodeid, int from_nodeid,
546 unsigned int flags, struct dlm_rsb **r_ret)
547{
548 struct dlm_rsb *r = NULL;
549 int our_nodeid = dlm_our_nodeid();
550 int from_local = 0;
551 int from_other = 0;
552 int from_dir = 0;
553 int create = 0;
554 int error;
555
556 if (flags & R_RECEIVE_REQUEST) {
557 if (from_nodeid == dir_nodeid)
558 from_dir = 1;
559 else
560 from_other = 1;
561 } else if (flags & R_REQUEST) {
562 from_local = 1;
563 }
564
565 /*
566 * flags & R_RECEIVE_RECOVER is from dlm_recover_master_copy, so
567 * from_nodeid has sent us a lock in dlm_recover_locks, believing
568 * we're the new master. Our local recovery may not have set
569 * res_master_nodeid to our_nodeid yet, so allow either. Don't
570 * create the rsb; dlm_recover_process_copy() will handle EBADR
571 * by resending.
572 *
573 * If someone sends us a request, we are the dir node, and we do
574 * not find the rsb anywhere, then recreate it. This happens if
575 * someone sends us a request after we have removed/freed an rsb
576 * from our toss list. (They sent a request instead of lookup
577 * because they are using an rsb from their toss list.)
578 */
579
580 if (from_local || from_dir ||
581 (from_other && (dir_nodeid == our_nodeid))) {
582 create = 1;
583 }
584
585 retry:
586 if (create) {
587 error = pre_rsb_struct(ls);
588 if (error < 0)
589 goto out;
590 }
591
592 spin_lock(&ls->ls_rsbtbl[b].lock);
593
594 error = dlm_search_rsb_tree(&ls->ls_rsbtbl[b].keep, name, len, &r);
595 if (error)
596 goto do_toss;
597
598 /*
599 * rsb is active, so we can't check master_nodeid without lock_rsb.
600 */
601
602 kref_get(&r->res_ref);
603 error = 0;
604 goto out_unlock;
605
606
607 do_toss:
608 error = dlm_search_rsb_tree(&ls->ls_rsbtbl[b].toss, name, len, &r);
609 if (error)
610 goto do_new;
611
612 /*
613 * rsb found inactive (master_nodeid may be out of date unless
614 * we are the dir_nodeid or were the master) No other thread
615 * is using this rsb because it's on the toss list, so we can
616 * look at or update res_master_nodeid without lock_rsb.
617 */
618
619 if ((r->res_master_nodeid != our_nodeid) && from_other) {
620 /* our rsb was not master, and another node (not the dir node)
621 has sent us a request */
622 log_debug(ls, "find_rsb toss from_other %d master %d dir %d %s",
623 from_nodeid, r->res_master_nodeid, dir_nodeid,
624 r->res_name);
625 error = -ENOTBLK;
626 goto out_unlock;
627 }
628
629 if ((r->res_master_nodeid != our_nodeid) && from_dir) {
630 /* don't think this should ever happen */
631 log_error(ls, "find_rsb toss from_dir %d master %d",
632 from_nodeid, r->res_master_nodeid);
633 dlm_print_rsb(r);
634 /* fix it and go on */
635 r->res_master_nodeid = our_nodeid;
636 r->res_nodeid = 0;
637 rsb_clear_flag(r, RSB_MASTER_UNCERTAIN);
638 r->res_first_lkid = 0;
639 }
640
641 if (from_local && (r->res_master_nodeid != our_nodeid)) {
642 /* Because we have held no locks on this rsb,
643 res_master_nodeid could have become stale. */
644 rsb_set_flag(r, RSB_MASTER_UNCERTAIN);
645 r->res_first_lkid = 0;
646 }
647
648 rb_erase(&r->res_hashnode, &ls->ls_rsbtbl[b].toss);
649 error = rsb_insert(r, &ls->ls_rsbtbl[b].keep);
650 goto out_unlock;
651
652
653 do_new:
654 /*
655 * rsb not found
656 */
657
658 if (error == -EBADR && !create)
659 goto out_unlock;
660
661 error = get_rsb_struct(ls, name, len, &r);
662 if (error == -EAGAIN) {
663 spin_unlock(&ls->ls_rsbtbl[b].lock);
664 goto retry;
665 }
666 if (error)
667 goto out_unlock;
668
669 r->res_hash = hash;
670 r->res_bucket = b;
671 r->res_dir_nodeid = dir_nodeid;
672 kref_init(&r->res_ref);
673
674 if (from_dir) {
675 /* want to see how often this happens */
676 log_debug(ls, "find_rsb new from_dir %d recreate %s",
677 from_nodeid, r->res_name);
678 r->res_master_nodeid = our_nodeid;
679 r->res_nodeid = 0;
680 goto out_add;
681 }
682
683 if (from_other && (dir_nodeid != our_nodeid)) {
684 /* should never happen */
685 log_error(ls, "find_rsb new from_other %d dir %d our %d %s",
686 from_nodeid, dir_nodeid, our_nodeid, r->res_name);
687 dlm_free_rsb(r);
688 r = NULL;
689 error = -ENOTBLK;
690 goto out_unlock;
691 }
692
693 if (from_other) {
694 log_debug(ls, "find_rsb new from_other %d dir %d %s",
695 from_nodeid, dir_nodeid, r->res_name);
696 }
697
698 if (dir_nodeid == our_nodeid) {
699 /* When we are the dir nodeid, we can set the master
700 node immediately */
701 r->res_master_nodeid = our_nodeid;
702 r->res_nodeid = 0;
703 } else {
704 /* set_master will send_lookup to dir_nodeid */
705 r->res_master_nodeid = 0;
706 r->res_nodeid = -1;
707 }
708
709 out_add:
710 error = rsb_insert(r, &ls->ls_rsbtbl[b].keep);
711 out_unlock:
712 spin_unlock(&ls->ls_rsbtbl[b].lock);
713 out:
714 *r_ret = r;
715 return error;
716}
717
718/* During recovery, other nodes can send us new MSTCPY locks (from
719 dlm_recover_locks) before we've made ourself master (in
720 dlm_recover_masters). */
721
722static int find_rsb_nodir(struct dlm_ls *ls, char *name, int len,
723 uint32_t hash, uint32_t b,
724 int dir_nodeid, int from_nodeid,
725 unsigned int flags, struct dlm_rsb **r_ret)
726{
727 struct dlm_rsb *r = NULL;
728 int our_nodeid = dlm_our_nodeid();
729 int recover = (flags & R_RECEIVE_RECOVER);
730 int error;
731
732 retry:
733 error = pre_rsb_struct(ls);
734 if (error < 0)
735 goto out;
736
737 spin_lock(&ls->ls_rsbtbl[b].lock);
738
739 error = dlm_search_rsb_tree(&ls->ls_rsbtbl[b].keep, name, len, &r);
740 if (error)
741 goto do_toss;
742
743 /*
744 * rsb is active, so we can't check master_nodeid without lock_rsb.
745 */
746
747 kref_get(&r->res_ref);
748 goto out_unlock;
749
750
751 do_toss:
752 error = dlm_search_rsb_tree(&ls->ls_rsbtbl[b].toss, name, len, &r);
753 if (error)
754 goto do_new;
755
756 /*
757 * rsb found inactive. No other thread is using this rsb because
758 * it's on the toss list, so we can look at or update
759 * res_master_nodeid without lock_rsb.
760 */
761
762 if (!recover && (r->res_master_nodeid != our_nodeid) && from_nodeid) {
763 /* our rsb is not master, and another node has sent us a
764 request; this should never happen */
765 log_error(ls, "find_rsb toss from_nodeid %d master %d dir %d",
766 from_nodeid, r->res_master_nodeid, dir_nodeid);
767 dlm_print_rsb(r);
768 error = -ENOTBLK;
769 goto out_unlock;
770 }
771
772 if (!recover && (r->res_master_nodeid != our_nodeid) &&
773 (dir_nodeid == our_nodeid)) {
774 /* our rsb is not master, and we are dir; may as well fix it;
775 this should never happen */
776 log_error(ls, "find_rsb toss our %d master %d dir %d",
777 our_nodeid, r->res_master_nodeid, dir_nodeid);
778 dlm_print_rsb(r);
779 r->res_master_nodeid = our_nodeid;
780 r->res_nodeid = 0;
781 }
782
783 rb_erase(&r->res_hashnode, &ls->ls_rsbtbl[b].toss);
784 error = rsb_insert(r, &ls->ls_rsbtbl[b].keep);
785 goto out_unlock;
786
787
788 do_new:
789 /*
790 * rsb not found
791 */
792
793 error = get_rsb_struct(ls, name, len, &r);
794 if (error == -EAGAIN) {
795 spin_unlock(&ls->ls_rsbtbl[b].lock);
796 goto retry;
797 }
798 if (error)
799 goto out_unlock;
800
801 r->res_hash = hash;
802 r->res_bucket = b;
803 r->res_dir_nodeid = dir_nodeid;
804 r->res_master_nodeid = dir_nodeid;
805 r->res_nodeid = (dir_nodeid == our_nodeid) ? 0 : dir_nodeid;
806 kref_init(&r->res_ref);
807
808 error = rsb_insert(r, &ls->ls_rsbtbl[b].keep);
809 out_unlock:
810 spin_unlock(&ls->ls_rsbtbl[b].lock);
811 out:
812 *r_ret = r;
813 return error;
814}
815
816static int find_rsb(struct dlm_ls *ls, char *name, int len, int from_nodeid,
817 unsigned int flags, struct dlm_rsb **r_ret)
818{
819 uint32_t hash, b;
820 int dir_nodeid;
821
822 if (len > DLM_RESNAME_MAXLEN)
823 return -EINVAL;
824
825 hash = jhash(name, len, 0);
826 b = hash & (ls->ls_rsbtbl_size - 1);
827
828 dir_nodeid = dlm_hash2nodeid(ls, hash);
829
830 if (dlm_no_directory(ls))
831 return find_rsb_nodir(ls, name, len, hash, b, dir_nodeid,
832 from_nodeid, flags, r_ret);
833 else
834 return find_rsb_dir(ls, name, len, hash, b, dir_nodeid,
835 from_nodeid, flags, r_ret);
836}
837
838/* we have received a request and found that res_master_nodeid != our_nodeid,
839 so we need to return an error or make ourself the master */
840
841static int validate_master_nodeid(struct dlm_ls *ls, struct dlm_rsb *r,
842 int from_nodeid)
843{
844 if (dlm_no_directory(ls)) {
845 log_error(ls, "find_rsb keep from_nodeid %d master %d dir %d",
846 from_nodeid, r->res_master_nodeid,
847 r->res_dir_nodeid);
848 dlm_print_rsb(r);
849 return -ENOTBLK;
850 }
851
852 if (from_nodeid != r->res_dir_nodeid) {
853 /* our rsb is not master, and another node (not the dir node)
854 has sent us a request. this is much more common when our
855 master_nodeid is zero, so limit debug to non-zero. */
856
857 if (r->res_master_nodeid) {
858 log_debug(ls, "validate master from_other %d master %d "
859 "dir %d first %x %s", from_nodeid,
860 r->res_master_nodeid, r->res_dir_nodeid,
861 r->res_first_lkid, r->res_name);
862 }
863 return -ENOTBLK;
864 } else {
865 /* our rsb is not master, but the dir nodeid has sent us a
866 request; this could happen with master 0 / res_nodeid -1 */
867
868 if (r->res_master_nodeid) {
869 log_error(ls, "validate master from_dir %d master %d "
870 "first %x %s",
871 from_nodeid, r->res_master_nodeid,
872 r->res_first_lkid, r->res_name);
873 }
874
875 r->res_master_nodeid = dlm_our_nodeid();
876 r->res_nodeid = 0;
877 return 0;
878 }
879}
880
881/*
882 * We're the dir node for this res and another node wants to know the
883 * master nodeid. During normal operation (non recovery) this is only
884 * called from receive_lookup(); master lookups when the local node is
885 * the dir node are done by find_rsb().
886 *
887 * normal operation, we are the dir node for a resource
888 * . _request_lock
889 * . set_master
890 * . send_lookup
891 * . receive_lookup
892 * . dlm_master_lookup flags 0
893 *
894 * recover directory, we are rebuilding dir for all resources
895 * . dlm_recover_directory
896 * . dlm_rcom_names
897 * remote node sends back the rsb names it is master of and we are dir of
898 * . dlm_master_lookup RECOVER_DIR (fix_master 0, from_master 1)
899 * we either create new rsb setting remote node as master, or find existing
900 * rsb and set master to be the remote node.
901 *
902 * recover masters, we are finding the new master for resources
903 * . dlm_recover_masters
904 * . recover_master
905 * . dlm_send_rcom_lookup
906 * . receive_rcom_lookup
907 * . dlm_master_lookup RECOVER_MASTER (fix_master 1, from_master 0)
908 */
909
910int dlm_master_lookup(struct dlm_ls *ls, int from_nodeid, char *name, int len,
911 unsigned int flags, int *r_nodeid, int *result)
912{
913 struct dlm_rsb *r = NULL;
914 uint32_t hash, b;
915 int from_master = (flags & DLM_LU_RECOVER_DIR);
916 int fix_master = (flags & DLM_LU_RECOVER_MASTER);
917 int our_nodeid = dlm_our_nodeid();
918 int dir_nodeid, error, toss_list = 0;
919
920 if (len > DLM_RESNAME_MAXLEN)
921 return -EINVAL;
922
923 if (from_nodeid == our_nodeid) {
924 log_error(ls, "dlm_master_lookup from our_nodeid %d flags %x",
925 our_nodeid, flags);
926 return -EINVAL;
927 }
928
929 hash = jhash(name, len, 0);
930 b = hash & (ls->ls_rsbtbl_size - 1);
931
932 dir_nodeid = dlm_hash2nodeid(ls, hash);
933 if (dir_nodeid != our_nodeid) {
934 log_error(ls, "dlm_master_lookup from %d dir %d our %d h %x %d",
935 from_nodeid, dir_nodeid, our_nodeid, hash,
936 ls->ls_num_nodes);
937 *r_nodeid = -1;
938 return -EINVAL;
939 }
940
941 retry:
942 error = pre_rsb_struct(ls);
943 if (error < 0)
944 return error;
945
946 spin_lock(&ls->ls_rsbtbl[b].lock);
947 error = dlm_search_rsb_tree(&ls->ls_rsbtbl[b].keep, name, len, &r);
948 if (!error) {
949 /* because the rsb is active, we need to lock_rsb before
950 checking/changing re_master_nodeid */
951
952 hold_rsb(r);
953 spin_unlock(&ls->ls_rsbtbl[b].lock);
954 lock_rsb(r);
955 goto found;
956 }
957
958 error = dlm_search_rsb_tree(&ls->ls_rsbtbl[b].toss, name, len, &r);
959 if (error)
960 goto not_found;
961
962 /* because the rsb is inactive (on toss list), it's not refcounted
963 and lock_rsb is not used, but is protected by the rsbtbl lock */
964
965 toss_list = 1;
966 found:
967 if (r->res_dir_nodeid != our_nodeid) {
968 /* should not happen, but may as well fix it and carry on */
969 log_error(ls, "dlm_master_lookup res_dir %d our %d %s",
970 r->res_dir_nodeid, our_nodeid, r->res_name);
971 r->res_dir_nodeid = our_nodeid;
972 }
973
974 if (fix_master && dlm_is_removed(ls, r->res_master_nodeid)) {
975 /* Recovery uses this function to set a new master when
976 the previous master failed. Setting NEW_MASTER will
977 force dlm_recover_masters to call recover_master on this
978 rsb even though the res_nodeid is no longer removed. */
979
980 r->res_master_nodeid = from_nodeid;
981 r->res_nodeid = from_nodeid;
982 rsb_set_flag(r, RSB_NEW_MASTER);
983
984 if (toss_list) {
985 /* I don't think we should ever find it on toss list. */
986 log_error(ls, "dlm_master_lookup fix_master on toss");
987 dlm_dump_rsb(r);
988 }
989 }
990
991 if (from_master && (r->res_master_nodeid != from_nodeid)) {
992 /* this will happen if from_nodeid became master during
993 a previous recovery cycle, and we aborted the previous
994 cycle before recovering this master value */
995
996 log_limit(ls, "dlm_master_lookup from_master %d "
997 "master_nodeid %d res_nodeid %d first %x %s",
998 from_nodeid, r->res_master_nodeid, r->res_nodeid,
999 r->res_first_lkid, r->res_name);
1000
1001 if (r->res_master_nodeid == our_nodeid) {
1002 log_error(ls, "from_master %d our_master", from_nodeid);
1003 dlm_dump_rsb(r);
1004 goto out_found;
1005 }
1006
1007 r->res_master_nodeid = from_nodeid;
1008 r->res_nodeid = from_nodeid;
1009 rsb_set_flag(r, RSB_NEW_MASTER);
1010 }
1011
1012 if (!r->res_master_nodeid) {
1013 /* this will happen if recovery happens while we're looking
1014 up the master for this rsb */
1015
1016 log_debug(ls, "dlm_master_lookup master 0 to %d first %x %s",
1017 from_nodeid, r->res_first_lkid, r->res_name);
1018 r->res_master_nodeid = from_nodeid;
1019 r->res_nodeid = from_nodeid;
1020 }
1021
1022 if (!from_master && !fix_master &&
1023 (r->res_master_nodeid == from_nodeid)) {
1024 /* this can happen when the master sends remove, the dir node
1025 finds the rsb on the keep list and ignores the remove,
1026 and the former master sends a lookup */
1027
1028 log_limit(ls, "dlm_master_lookup from master %d flags %x "
1029 "first %x %s", from_nodeid, flags,
1030 r->res_first_lkid, r->res_name);
1031 }
1032
1033 out_found:
1034 *r_nodeid = r->res_master_nodeid;
1035 if (result)
1036 *result = DLM_LU_MATCH;
1037
1038 if (toss_list) {
1039 r->res_toss_time = jiffies;
1040 /* the rsb was inactive (on toss list) */
1041 spin_unlock(&ls->ls_rsbtbl[b].lock);
1042 } else {
1043 /* the rsb was active */
1044 unlock_rsb(r);
1045 put_rsb(r);
1046 }
1047 return 0;
1048
1049 not_found:
1050 error = get_rsb_struct(ls, name, len, &r);
1051 if (error == -EAGAIN) {
1052 spin_unlock(&ls->ls_rsbtbl[b].lock);
1053 goto retry;
1054 }
1055 if (error)
1056 goto out_unlock;
1057
1058 r->res_hash = hash;
1059 r->res_bucket = b;
1060 r->res_dir_nodeid = our_nodeid;
1061 r->res_master_nodeid = from_nodeid;
1062 r->res_nodeid = from_nodeid;
1063 kref_init(&r->res_ref);
1064 r->res_toss_time = jiffies;
1065
1066 error = rsb_insert(r, &ls->ls_rsbtbl[b].toss);
1067 if (error) {
1068 /* should never happen */
1069 dlm_free_rsb(r);
1070 spin_unlock(&ls->ls_rsbtbl[b].lock);
1071 goto retry;
1072 }
1073
1074 if (result)
1075 *result = DLM_LU_ADD;
1076 *r_nodeid = from_nodeid;
1077 error = 0;
1078 out_unlock:
1079 spin_unlock(&ls->ls_rsbtbl[b].lock);
1080 return error;
1081}
1082
1083static void dlm_dump_rsb_hash(struct dlm_ls *ls, uint32_t hash)
1084{
1085 struct rb_node *n;
1086 struct dlm_rsb *r;
1087 int i;
1088
1089 for (i = 0; i < ls->ls_rsbtbl_size; i++) {
1090 spin_lock(&ls->ls_rsbtbl[i].lock);
1091 for (n = rb_first(&ls->ls_rsbtbl[i].keep); n; n = rb_next(n)) {
1092 r = rb_entry(n, struct dlm_rsb, res_hashnode);
1093 if (r->res_hash == hash)
1094 dlm_dump_rsb(r);
1095 }
1096 spin_unlock(&ls->ls_rsbtbl[i].lock);
1097 }
1098}
1099
1100void dlm_dump_rsb_name(struct dlm_ls *ls, char *name, int len)
1101{
1102 struct dlm_rsb *r = NULL;
1103 uint32_t hash, b;
1104 int error;
1105
1106 hash = jhash(name, len, 0);
1107 b = hash & (ls->ls_rsbtbl_size - 1);
1108
1109 spin_lock(&ls->ls_rsbtbl[b].lock);
1110 error = dlm_search_rsb_tree(&ls->ls_rsbtbl[b].keep, name, len, &r);
1111 if (!error)
1112 goto out_dump;
1113
1114 error = dlm_search_rsb_tree(&ls->ls_rsbtbl[b].toss, name, len, &r);
1115 if (error)
1116 goto out;
1117 out_dump:
1118 dlm_dump_rsb(r);
1119 out:
1120 spin_unlock(&ls->ls_rsbtbl[b].lock);
1121}
1122
1123static void toss_rsb(struct kref *kref)
1124{
1125 struct dlm_rsb *r = container_of(kref, struct dlm_rsb, res_ref);
1126 struct dlm_ls *ls = r->res_ls;
1127
1128 DLM_ASSERT(list_empty(&r->res_root_list), dlm_print_rsb(r););
1129 kref_init(&r->res_ref);
1130 rb_erase(&r->res_hashnode, &ls->ls_rsbtbl[r->res_bucket].keep);
1131 rsb_insert(r, &ls->ls_rsbtbl[r->res_bucket].toss);
1132 r->res_toss_time = jiffies;
1133 ls->ls_rsbtbl[r->res_bucket].flags |= DLM_RTF_SHRINK;
1134 if (r->res_lvbptr) {
1135 dlm_free_lvb(r->res_lvbptr);
1136 r->res_lvbptr = NULL;
1137 }
1138}
1139
1140/* See comment for unhold_lkb */
1141
1142static void unhold_rsb(struct dlm_rsb *r)
1143{
1144 int rv;
1145 rv = kref_put(&r->res_ref, toss_rsb);
1146 DLM_ASSERT(!rv, dlm_dump_rsb(r););
1147}
1148
1149static void kill_rsb(struct kref *kref)
1150{
1151 struct dlm_rsb *r = container_of(kref, struct dlm_rsb, res_ref);
1152
1153 /* All work is done after the return from kref_put() so we
1154 can release the write_lock before the remove and free. */
1155
1156 DLM_ASSERT(list_empty(&r->res_lookup), dlm_dump_rsb(r););
1157 DLM_ASSERT(list_empty(&r->res_grantqueue), dlm_dump_rsb(r););
1158 DLM_ASSERT(list_empty(&r->res_convertqueue), dlm_dump_rsb(r););
1159 DLM_ASSERT(list_empty(&r->res_waitqueue), dlm_dump_rsb(r););
1160 DLM_ASSERT(list_empty(&r->res_root_list), dlm_dump_rsb(r););
1161 DLM_ASSERT(list_empty(&r->res_recover_list), dlm_dump_rsb(r););
1162}
1163
1164/* Attaching/detaching lkb's from rsb's is for rsb reference counting.
1165 The rsb must exist as long as any lkb's for it do. */
1166
1167static void attach_lkb(struct dlm_rsb *r, struct dlm_lkb *lkb)
1168{
1169 hold_rsb(r);
1170 lkb->lkb_resource = r;
1171}
1172
1173static void detach_lkb(struct dlm_lkb *lkb)
1174{
1175 if (lkb->lkb_resource) {
1176 put_rsb(lkb->lkb_resource);
1177 lkb->lkb_resource = NULL;
1178 }
1179}
1180
1181static int create_lkb(struct dlm_ls *ls, struct dlm_lkb **lkb_ret)
1182{
1183 struct dlm_lkb *lkb;
1184 int rv;
1185
1186 lkb = dlm_allocate_lkb(ls);
1187 if (!lkb)
1188 return -ENOMEM;
1189
1190 lkb->lkb_nodeid = -1;
1191 lkb->lkb_grmode = DLM_LOCK_IV;
1192 kref_init(&lkb->lkb_ref);
1193 INIT_LIST_HEAD(&lkb->lkb_ownqueue);
1194 INIT_LIST_HEAD(&lkb->lkb_rsb_lookup);
1195 INIT_LIST_HEAD(&lkb->lkb_time_list);
1196 INIT_LIST_HEAD(&lkb->lkb_cb_list);
1197 mutex_init(&lkb->lkb_cb_mutex);
1198 INIT_WORK(&lkb->lkb_cb_work, dlm_callback_work);
1199
1200 idr_preload(GFP_NOFS);
1201 spin_lock(&ls->ls_lkbidr_spin);
1202 rv = idr_alloc(&ls->ls_lkbidr, lkb, 1, 0, GFP_NOWAIT);
1203 if (rv >= 0)
1204 lkb->lkb_id = rv;
1205 spin_unlock(&ls->ls_lkbidr_spin);
1206 idr_preload_end();
1207
1208 if (rv < 0) {
1209 log_error(ls, "create_lkb idr error %d", rv);
1210 dlm_free_lkb(lkb);
1211 return rv;
1212 }
1213
1214 *lkb_ret = lkb;
1215 return 0;
1216}
1217
1218static int find_lkb(struct dlm_ls *ls, uint32_t lkid, struct dlm_lkb **lkb_ret)
1219{
1220 struct dlm_lkb *lkb;
1221
1222 spin_lock(&ls->ls_lkbidr_spin);
1223 lkb = idr_find(&ls->ls_lkbidr, lkid);
1224 if (lkb)
1225 kref_get(&lkb->lkb_ref);
1226 spin_unlock(&ls->ls_lkbidr_spin);
1227
1228 *lkb_ret = lkb;
1229 return lkb ? 0 : -ENOENT;
1230}
1231
1232static void kill_lkb(struct kref *kref)
1233{
1234 struct dlm_lkb *lkb = container_of(kref, struct dlm_lkb, lkb_ref);
1235
1236 /* All work is done after the return from kref_put() so we
1237 can release the write_lock before the detach_lkb */
1238
1239 DLM_ASSERT(!lkb->lkb_status, dlm_print_lkb(lkb););
1240}
1241
1242/* __put_lkb() is used when an lkb may not have an rsb attached to
1243 it so we need to provide the lockspace explicitly */
1244
1245static int __put_lkb(struct dlm_ls *ls, struct dlm_lkb *lkb)
1246{
1247 uint32_t lkid = lkb->lkb_id;
1248
1249 spin_lock(&ls->ls_lkbidr_spin);
1250 if (kref_put(&lkb->lkb_ref, kill_lkb)) {
1251 idr_remove(&ls->ls_lkbidr, lkid);
1252 spin_unlock(&ls->ls_lkbidr_spin);
1253
1254 detach_lkb(lkb);
1255
1256 /* for local/process lkbs, lvbptr points to caller's lksb */
1257 if (lkb->lkb_lvbptr && is_master_copy(lkb))
1258 dlm_free_lvb(lkb->lkb_lvbptr);
1259 dlm_free_lkb(lkb);
1260 return 1;
1261 } else {
1262 spin_unlock(&ls->ls_lkbidr_spin);
1263 return 0;
1264 }
1265}
1266
1267int dlm_put_lkb(struct dlm_lkb *lkb)
1268{
1269 struct dlm_ls *ls;
1270
1271 DLM_ASSERT(lkb->lkb_resource, dlm_print_lkb(lkb););
1272 DLM_ASSERT(lkb->lkb_resource->res_ls, dlm_print_lkb(lkb););
1273
1274 ls = lkb->lkb_resource->res_ls;
1275 return __put_lkb(ls, lkb);
1276}
1277
1278/* This is only called to add a reference when the code already holds
1279 a valid reference to the lkb, so there's no need for locking. */
1280
1281static inline void hold_lkb(struct dlm_lkb *lkb)
1282{
1283 kref_get(&lkb->lkb_ref);
1284}
1285
1286/* This is called when we need to remove a reference and are certain
1287 it's not the last ref. e.g. del_lkb is always called between a
1288 find_lkb/put_lkb and is always the inverse of a previous add_lkb.
1289 put_lkb would work fine, but would involve unnecessary locking */
1290
1291static inline void unhold_lkb(struct dlm_lkb *lkb)
1292{
1293 int rv;
1294 rv = kref_put(&lkb->lkb_ref, kill_lkb);
1295 DLM_ASSERT(!rv, dlm_print_lkb(lkb););
1296}
1297
1298static void lkb_add_ordered(struct list_head *new, struct list_head *head,
1299 int mode)
1300{
1301 struct dlm_lkb *lkb = NULL;
1302
1303 list_for_each_entry(lkb, head, lkb_statequeue)
1304 if (lkb->lkb_rqmode < mode)
1305 break;
1306
1307 __list_add(new, lkb->lkb_statequeue.prev, &lkb->lkb_statequeue);
1308}
1309
1310/* add/remove lkb to rsb's grant/convert/wait queue */
1311
1312static void add_lkb(struct dlm_rsb *r, struct dlm_lkb *lkb, int status)
1313{
1314 kref_get(&lkb->lkb_ref);
1315
1316 DLM_ASSERT(!lkb->lkb_status, dlm_print_lkb(lkb););
1317
1318 lkb->lkb_timestamp = ktime_get();
1319
1320 lkb->lkb_status = status;
1321
1322 switch (status) {
1323 case DLM_LKSTS_WAITING:
1324 if (lkb->lkb_exflags & DLM_LKF_HEADQUE)
1325 list_add(&lkb->lkb_statequeue, &r->res_waitqueue);
1326 else
1327 list_add_tail(&lkb->lkb_statequeue, &r->res_waitqueue);
1328 break;
1329 case DLM_LKSTS_GRANTED:
1330 /* convention says granted locks kept in order of grmode */
1331 lkb_add_ordered(&lkb->lkb_statequeue, &r->res_grantqueue,
1332 lkb->lkb_grmode);
1333 break;
1334 case DLM_LKSTS_CONVERT:
1335 if (lkb->lkb_exflags & DLM_LKF_HEADQUE)
1336 list_add(&lkb->lkb_statequeue, &r->res_convertqueue);
1337 else
1338 list_add_tail(&lkb->lkb_statequeue,
1339 &r->res_convertqueue);
1340 break;
1341 default:
1342 DLM_ASSERT(0, dlm_print_lkb(lkb); printk("sts=%d\n", status););
1343 }
1344}
1345
1346static void del_lkb(struct dlm_rsb *r, struct dlm_lkb *lkb)
1347{
1348 lkb->lkb_status = 0;
1349 list_del(&lkb->lkb_statequeue);
1350 unhold_lkb(lkb);
1351}
1352
1353static void move_lkb(struct dlm_rsb *r, struct dlm_lkb *lkb, int sts)
1354{
1355 hold_lkb(lkb);
1356 del_lkb(r, lkb);
1357 add_lkb(r, lkb, sts);
1358 unhold_lkb(lkb);
1359}
1360
1361static int msg_reply_type(int mstype)
1362{
1363 switch (mstype) {
1364 case DLM_MSG_REQUEST:
1365 return DLM_MSG_REQUEST_REPLY;
1366 case DLM_MSG_CONVERT:
1367 return DLM_MSG_CONVERT_REPLY;
1368 case DLM_MSG_UNLOCK:
1369 return DLM_MSG_UNLOCK_REPLY;
1370 case DLM_MSG_CANCEL:
1371 return DLM_MSG_CANCEL_REPLY;
1372 case DLM_MSG_LOOKUP:
1373 return DLM_MSG_LOOKUP_REPLY;
1374 }
1375 return -1;
1376}
1377
1378static int nodeid_warned(int nodeid, int num_nodes, int *warned)
1379{
1380 int i;
1381
1382 for (i = 0; i < num_nodes; i++) {
1383 if (!warned[i]) {
1384 warned[i] = nodeid;
1385 return 0;
1386 }
1387 if (warned[i] == nodeid)
1388 return 1;
1389 }
1390 return 0;
1391}
1392
1393void dlm_scan_waiters(struct dlm_ls *ls)
1394{
1395 struct dlm_lkb *lkb;
1396 s64 us;
1397 s64 debug_maxus = 0;
1398 u32 debug_scanned = 0;
1399 u32 debug_expired = 0;
1400 int num_nodes = 0;
1401 int *warned = NULL;
1402
1403 if (!dlm_config.ci_waitwarn_us)
1404 return;
1405
1406 mutex_lock(&ls->ls_waiters_mutex);
1407
1408 list_for_each_entry(lkb, &ls->ls_waiters, lkb_wait_reply) {
1409 if (!lkb->lkb_wait_time)
1410 continue;
1411
1412 debug_scanned++;
1413
1414 us = ktime_to_us(ktime_sub(ktime_get(), lkb->lkb_wait_time));
1415
1416 if (us < dlm_config.ci_waitwarn_us)
1417 continue;
1418
1419 lkb->lkb_wait_time = 0;
1420
1421 debug_expired++;
1422 if (us > debug_maxus)
1423 debug_maxus = us;
1424
1425 if (!num_nodes) {
1426 num_nodes = ls->ls_num_nodes;
1427 warned = kcalloc(num_nodes, sizeof(int), GFP_KERNEL);
1428 }
1429 if (!warned)
1430 continue;
1431 if (nodeid_warned(lkb->lkb_wait_nodeid, num_nodes, warned))
1432 continue;
1433
1434 log_error(ls, "waitwarn %x %lld %d us check connection to "
1435 "node %d", lkb->lkb_id, (long long)us,
1436 dlm_config.ci_waitwarn_us, lkb->lkb_wait_nodeid);
1437 }
1438 mutex_unlock(&ls->ls_waiters_mutex);
1439 kfree(warned);
1440
1441 if (debug_expired)
1442 log_debug(ls, "scan_waiters %u warn %u over %d us max %lld us",
1443 debug_scanned, debug_expired,
1444 dlm_config.ci_waitwarn_us, (long long)debug_maxus);
1445}
1446
1447/* add/remove lkb from global waiters list of lkb's waiting for
1448 a reply from a remote node */
1449
1450static int add_to_waiters(struct dlm_lkb *lkb, int mstype, int to_nodeid)
1451{
1452 struct dlm_ls *ls = lkb->lkb_resource->res_ls;
1453 int error = 0;
1454
1455 mutex_lock(&ls->ls_waiters_mutex);
1456
1457 if (is_overlap_unlock(lkb) ||
1458 (is_overlap_cancel(lkb) && (mstype == DLM_MSG_CANCEL))) {
1459 error = -EINVAL;
1460 goto out;
1461 }
1462
1463 if (lkb->lkb_wait_type || is_overlap_cancel(lkb)) {
1464 switch (mstype) {
1465 case DLM_MSG_UNLOCK:
1466 lkb->lkb_flags |= DLM_IFL_OVERLAP_UNLOCK;
1467 break;
1468 case DLM_MSG_CANCEL:
1469 lkb->lkb_flags |= DLM_IFL_OVERLAP_CANCEL;
1470 break;
1471 default:
1472 error = -EBUSY;
1473 goto out;
1474 }
1475 lkb->lkb_wait_count++;
1476 hold_lkb(lkb);
1477
1478 log_debug(ls, "addwait %x cur %d overlap %d count %d f %x",
1479 lkb->lkb_id, lkb->lkb_wait_type, mstype,
1480 lkb->lkb_wait_count, lkb->lkb_flags);
1481 goto out;
1482 }
1483
1484 DLM_ASSERT(!lkb->lkb_wait_count,
1485 dlm_print_lkb(lkb);
1486 printk("wait_count %d\n", lkb->lkb_wait_count););
1487
1488 lkb->lkb_wait_count++;
1489 lkb->lkb_wait_type = mstype;
1490 lkb->lkb_wait_time = ktime_get();
1491 lkb->lkb_wait_nodeid = to_nodeid; /* for debugging */
1492 hold_lkb(lkb);
1493 list_add(&lkb->lkb_wait_reply, &ls->ls_waiters);
1494 out:
1495 if (error)
1496 log_error(ls, "addwait error %x %d flags %x %d %d %s",
1497 lkb->lkb_id, error, lkb->lkb_flags, mstype,
1498 lkb->lkb_wait_type, lkb->lkb_resource->res_name);
1499 mutex_unlock(&ls->ls_waiters_mutex);
1500 return error;
1501}
1502
1503/* We clear the RESEND flag because we might be taking an lkb off the waiters
1504 list as part of process_requestqueue (e.g. a lookup that has an optimized
1505 request reply on the requestqueue) between dlm_recover_waiters_pre() which
1506 set RESEND and dlm_recover_waiters_post() */
1507
1508static int _remove_from_waiters(struct dlm_lkb *lkb, int mstype,
1509 struct dlm_message *ms)
1510{
1511 struct dlm_ls *ls = lkb->lkb_resource->res_ls;
1512 int overlap_done = 0;
1513
1514 if (is_overlap_unlock(lkb) && (mstype == DLM_MSG_UNLOCK_REPLY)) {
1515 log_debug(ls, "remwait %x unlock_reply overlap", lkb->lkb_id);
1516 lkb->lkb_flags &= ~DLM_IFL_OVERLAP_UNLOCK;
1517 overlap_done = 1;
1518 goto out_del;
1519 }
1520
1521 if (is_overlap_cancel(lkb) && (mstype == DLM_MSG_CANCEL_REPLY)) {
1522 log_debug(ls, "remwait %x cancel_reply overlap", lkb->lkb_id);
1523 lkb->lkb_flags &= ~DLM_IFL_OVERLAP_CANCEL;
1524 overlap_done = 1;
1525 goto out_del;
1526 }
1527
1528 /* Cancel state was preemptively cleared by a successful convert,
1529 see next comment, nothing to do. */
1530
1531 if ((mstype == DLM_MSG_CANCEL_REPLY) &&
1532 (lkb->lkb_wait_type != DLM_MSG_CANCEL)) {
1533 log_debug(ls, "remwait %x cancel_reply wait_type %d",
1534 lkb->lkb_id, lkb->lkb_wait_type);
1535 return -1;
1536 }
1537
1538 /* Remove for the convert reply, and premptively remove for the
1539 cancel reply. A convert has been granted while there's still
1540 an outstanding cancel on it (the cancel is moot and the result
1541 in the cancel reply should be 0). We preempt the cancel reply
1542 because the app gets the convert result and then can follow up
1543 with another op, like convert. This subsequent op would see the
1544 lingering state of the cancel and fail with -EBUSY. */
1545
1546 if ((mstype == DLM_MSG_CONVERT_REPLY) &&
1547 (lkb->lkb_wait_type == DLM_MSG_CONVERT) &&
1548 is_overlap_cancel(lkb) && ms && !ms->m_result) {
1549 log_debug(ls, "remwait %x convert_reply zap overlap_cancel",
1550 lkb->lkb_id);
1551 lkb->lkb_wait_type = 0;
1552 lkb->lkb_flags &= ~DLM_IFL_OVERLAP_CANCEL;
1553 lkb->lkb_wait_count--;
1554 goto out_del;
1555 }
1556
1557 /* N.B. type of reply may not always correspond to type of original
1558 msg due to lookup->request optimization, verify others? */
1559
1560 if (lkb->lkb_wait_type) {
1561 lkb->lkb_wait_type = 0;
1562 goto out_del;
1563 }
1564
1565 log_error(ls, "remwait error %x remote %d %x msg %d flags %x no wait",
1566 lkb->lkb_id, ms ? ms->m_header.h_nodeid : 0, lkb->lkb_remid,
1567 mstype, lkb->lkb_flags);
1568 return -1;
1569
1570 out_del:
1571 /* the force-unlock/cancel has completed and we haven't recvd a reply
1572 to the op that was in progress prior to the unlock/cancel; we
1573 give up on any reply to the earlier op. FIXME: not sure when/how
1574 this would happen */
1575
1576 if (overlap_done && lkb->lkb_wait_type) {
1577 log_error(ls, "remwait error %x reply %d wait_type %d overlap",
1578 lkb->lkb_id, mstype, lkb->lkb_wait_type);
1579 lkb->lkb_wait_count--;
1580 lkb->lkb_wait_type = 0;
1581 }
1582
1583 DLM_ASSERT(lkb->lkb_wait_count, dlm_print_lkb(lkb););
1584
1585 lkb->lkb_flags &= ~DLM_IFL_RESEND;
1586 lkb->lkb_wait_count--;
1587 if (!lkb->lkb_wait_count)
1588 list_del_init(&lkb->lkb_wait_reply);
1589 unhold_lkb(lkb);
1590 return 0;
1591}
1592
1593static int remove_from_waiters(struct dlm_lkb *lkb, int mstype)
1594{
1595 struct dlm_ls *ls = lkb->lkb_resource->res_ls;
1596 int error;
1597
1598 mutex_lock(&ls->ls_waiters_mutex);
1599 error = _remove_from_waiters(lkb, mstype, NULL);
1600 mutex_unlock(&ls->ls_waiters_mutex);
1601 return error;
1602}
1603
1604/* Handles situations where we might be processing a "fake" or "stub" reply in
1605 which we can't try to take waiters_mutex again. */
1606
1607static int remove_from_waiters_ms(struct dlm_lkb *lkb, struct dlm_message *ms)
1608{
1609 struct dlm_ls *ls = lkb->lkb_resource->res_ls;
1610 int error;
1611
1612 if (ms->m_flags != DLM_IFL_STUB_MS)
1613 mutex_lock(&ls->ls_waiters_mutex);
1614 error = _remove_from_waiters(lkb, ms->m_type, ms);
1615 if (ms->m_flags != DLM_IFL_STUB_MS)
1616 mutex_unlock(&ls->ls_waiters_mutex);
1617 return error;
1618}
1619
1620/* If there's an rsb for the same resource being removed, ensure
1621 that the remove message is sent before the new lookup message.
1622 It should be rare to need a delay here, but if not, then it may
1623 be worthwhile to add a proper wait mechanism rather than a delay. */
1624
1625static void wait_pending_remove(struct dlm_rsb *r)
1626{
1627 struct dlm_ls *ls = r->res_ls;
1628 restart:
1629 spin_lock(&ls->ls_remove_spin);
1630 if (ls->ls_remove_len &&
1631 !rsb_cmp(r, ls->ls_remove_name, ls->ls_remove_len)) {
1632 log_debug(ls, "delay lookup for remove dir %d %s",
1633 r->res_dir_nodeid, r->res_name);
1634 spin_unlock(&ls->ls_remove_spin);
1635 msleep(1);
1636 goto restart;
1637 }
1638 spin_unlock(&ls->ls_remove_spin);
1639}
1640
1641/*
1642 * ls_remove_spin protects ls_remove_name and ls_remove_len which are
1643 * read by other threads in wait_pending_remove. ls_remove_names
1644 * and ls_remove_lens are only used by the scan thread, so they do
1645 * not need protection.
1646 */
1647
1648static void shrink_bucket(struct dlm_ls *ls, int b)
1649{
1650 struct rb_node *n, *next;
1651 struct dlm_rsb *r;
1652 char *name;
1653 int our_nodeid = dlm_our_nodeid();
1654 int remote_count = 0;
1655 int need_shrink = 0;
1656 int i, len, rv;
1657
1658 memset(&ls->ls_remove_lens, 0, sizeof(int) * DLM_REMOVE_NAMES_MAX);
1659
1660 spin_lock(&ls->ls_rsbtbl[b].lock);
1661
1662 if (!(ls->ls_rsbtbl[b].flags & DLM_RTF_SHRINK)) {
1663 spin_unlock(&ls->ls_rsbtbl[b].lock);
1664 return;
1665 }
1666
1667 for (n = rb_first(&ls->ls_rsbtbl[b].toss); n; n = next) {
1668 next = rb_next(n);
1669 r = rb_entry(n, struct dlm_rsb, res_hashnode);
1670
1671 /* If we're the directory record for this rsb, and
1672 we're not the master of it, then we need to wait
1673 for the master node to send us a dir remove for
1674 before removing the dir record. */
1675
1676 if (!dlm_no_directory(ls) &&
1677 (r->res_master_nodeid != our_nodeid) &&
1678 (dlm_dir_nodeid(r) == our_nodeid)) {
1679 continue;
1680 }
1681
1682 need_shrink = 1;
1683
1684 if (!time_after_eq(jiffies, r->res_toss_time +
1685 dlm_config.ci_toss_secs * HZ)) {
1686 continue;
1687 }
1688
1689 if (!dlm_no_directory(ls) &&
1690 (r->res_master_nodeid == our_nodeid) &&
1691 (dlm_dir_nodeid(r) != our_nodeid)) {
1692
1693 /* We're the master of this rsb but we're not
1694 the directory record, so we need to tell the
1695 dir node to remove the dir record. */
1696
1697 ls->ls_remove_lens[remote_count] = r->res_length;
1698 memcpy(ls->ls_remove_names[remote_count], r->res_name,
1699 DLM_RESNAME_MAXLEN);
1700 remote_count++;
1701
1702 if (remote_count >= DLM_REMOVE_NAMES_MAX)
1703 break;
1704 continue;
1705 }
1706
1707 if (!kref_put(&r->res_ref, kill_rsb)) {
1708 log_error(ls, "tossed rsb in use %s", r->res_name);
1709 continue;
1710 }
1711
1712 rb_erase(&r->res_hashnode, &ls->ls_rsbtbl[b].toss);
1713 dlm_free_rsb(r);
1714 }
1715
1716 if (need_shrink)
1717 ls->ls_rsbtbl[b].flags |= DLM_RTF_SHRINK;
1718 else
1719 ls->ls_rsbtbl[b].flags &= ~DLM_RTF_SHRINK;
1720 spin_unlock(&ls->ls_rsbtbl[b].lock);
1721
1722 /*
1723 * While searching for rsb's to free, we found some that require
1724 * remote removal. We leave them in place and find them again here
1725 * so there is a very small gap between removing them from the toss
1726 * list and sending the removal. Keeping this gap small is
1727 * important to keep us (the master node) from being out of sync
1728 * with the remote dir node for very long.
1729 *
1730 * From the time the rsb is removed from toss until just after
1731 * send_remove, the rsb name is saved in ls_remove_name. A new
1732 * lookup checks this to ensure that a new lookup message for the
1733 * same resource name is not sent just before the remove message.
1734 */
1735
1736 for (i = 0; i < remote_count; i++) {
1737 name = ls->ls_remove_names[i];
1738 len = ls->ls_remove_lens[i];
1739
1740 spin_lock(&ls->ls_rsbtbl[b].lock);
1741 rv = dlm_search_rsb_tree(&ls->ls_rsbtbl[b].toss, name, len, &r);
1742 if (rv) {
1743 spin_unlock(&ls->ls_rsbtbl[b].lock);
1744 log_debug(ls, "remove_name not toss %s", name);
1745 continue;
1746 }
1747
1748 if (r->res_master_nodeid != our_nodeid) {
1749 spin_unlock(&ls->ls_rsbtbl[b].lock);
1750 log_debug(ls, "remove_name master %d dir %d our %d %s",
1751 r->res_master_nodeid, r->res_dir_nodeid,
1752 our_nodeid, name);
1753 continue;
1754 }
1755
1756 if (r->res_dir_nodeid == our_nodeid) {
1757 /* should never happen */
1758 spin_unlock(&ls->ls_rsbtbl[b].lock);
1759 log_error(ls, "remove_name dir %d master %d our %d %s",
1760 r->res_dir_nodeid, r->res_master_nodeid,
1761 our_nodeid, name);
1762 continue;
1763 }
1764
1765 if (!time_after_eq(jiffies, r->res_toss_time +
1766 dlm_config.ci_toss_secs * HZ)) {
1767 spin_unlock(&ls->ls_rsbtbl[b].lock);
1768 log_debug(ls, "remove_name toss_time %lu now %lu %s",
1769 r->res_toss_time, jiffies, name);
1770 continue;
1771 }
1772
1773 if (!kref_put(&r->res_ref, kill_rsb)) {
1774 spin_unlock(&ls->ls_rsbtbl[b].lock);
1775 log_error(ls, "remove_name in use %s", name);
1776 continue;
1777 }
1778
1779 rb_erase(&r->res_hashnode, &ls->ls_rsbtbl[b].toss);
1780
1781 /* block lookup of same name until we've sent remove */
1782 spin_lock(&ls->ls_remove_spin);
1783 ls->ls_remove_len = len;
1784 memcpy(ls->ls_remove_name, name, DLM_RESNAME_MAXLEN);
1785 spin_unlock(&ls->ls_remove_spin);
1786 spin_unlock(&ls->ls_rsbtbl[b].lock);
1787
1788 send_remove(r);
1789
1790 /* allow lookup of name again */
1791 spin_lock(&ls->ls_remove_spin);
1792 ls->ls_remove_len = 0;
1793 memset(ls->ls_remove_name, 0, DLM_RESNAME_MAXLEN);
1794 spin_unlock(&ls->ls_remove_spin);
1795
1796 dlm_free_rsb(r);
1797 }
1798}
1799
1800void dlm_scan_rsbs(struct dlm_ls *ls)
1801{
1802 int i;
1803
1804 for (i = 0; i < ls->ls_rsbtbl_size; i++) {
1805 shrink_bucket(ls, i);
1806 if (dlm_locking_stopped(ls))
1807 break;
1808 cond_resched();
1809 }
1810}
1811
1812static void add_timeout(struct dlm_lkb *lkb)
1813{
1814 struct dlm_ls *ls = lkb->lkb_resource->res_ls;
1815
1816 if (is_master_copy(lkb))
1817 return;
1818
1819 if (test_bit(LSFL_TIMEWARN, &ls->ls_flags) &&
1820 !(lkb->lkb_exflags & DLM_LKF_NODLCKWT)) {
1821 lkb->lkb_flags |= DLM_IFL_WATCH_TIMEWARN;
1822 goto add_it;
1823 }
1824 if (lkb->lkb_exflags & DLM_LKF_TIMEOUT)
1825 goto add_it;
1826 return;
1827
1828 add_it:
1829 DLM_ASSERT(list_empty(&lkb->lkb_time_list), dlm_print_lkb(lkb););
1830 mutex_lock(&ls->ls_timeout_mutex);
1831 hold_lkb(lkb);
1832 list_add_tail(&lkb->lkb_time_list, &ls->ls_timeout);
1833 mutex_unlock(&ls->ls_timeout_mutex);
1834}
1835
1836static void del_timeout(struct dlm_lkb *lkb)
1837{
1838 struct dlm_ls *ls = lkb->lkb_resource->res_ls;
1839
1840 mutex_lock(&ls->ls_timeout_mutex);
1841 if (!list_empty(&lkb->lkb_time_list)) {
1842 list_del_init(&lkb->lkb_time_list);
1843 unhold_lkb(lkb);
1844 }
1845 mutex_unlock(&ls->ls_timeout_mutex);
1846}
1847
1848/* FIXME: is it safe to look at lkb_exflags, lkb_flags, lkb_timestamp, and
1849 lkb_lksb_timeout without lock_rsb? Note: we can't lock timeout_mutex
1850 and then lock rsb because of lock ordering in add_timeout. We may need
1851 to specify some special timeout-related bits in the lkb that are just to
1852 be accessed under the timeout_mutex. */
1853
1854void dlm_scan_timeout(struct dlm_ls *ls)
1855{
1856 struct dlm_rsb *r;
1857 struct dlm_lkb *lkb;
1858 int do_cancel, do_warn;
1859 s64 wait_us;
1860
1861 for (;;) {
1862 if (dlm_locking_stopped(ls))
1863 break;
1864
1865 do_cancel = 0;
1866 do_warn = 0;
1867 mutex_lock(&ls->ls_timeout_mutex);
1868 list_for_each_entry(lkb, &ls->ls_timeout, lkb_time_list) {
1869
1870 wait_us = ktime_to_us(ktime_sub(ktime_get(),
1871 lkb->lkb_timestamp));
1872
1873 if ((lkb->lkb_exflags & DLM_LKF_TIMEOUT) &&
1874 wait_us >= (lkb->lkb_timeout_cs * 10000))
1875 do_cancel = 1;
1876
1877 if ((lkb->lkb_flags & DLM_IFL_WATCH_TIMEWARN) &&
1878 wait_us >= dlm_config.ci_timewarn_cs * 10000)
1879 do_warn = 1;
1880
1881 if (!do_cancel && !do_warn)
1882 continue;
1883 hold_lkb(lkb);
1884 break;
1885 }
1886 mutex_unlock(&ls->ls_timeout_mutex);
1887
1888 if (!do_cancel && !do_warn)
1889 break;
1890
1891 r = lkb->lkb_resource;
1892 hold_rsb(r);
1893 lock_rsb(r);
1894
1895 if (do_warn) {
1896 /* clear flag so we only warn once */
1897 lkb->lkb_flags &= ~DLM_IFL_WATCH_TIMEWARN;
1898 if (!(lkb->lkb_exflags & DLM_LKF_TIMEOUT))
1899 del_timeout(lkb);
1900 dlm_timeout_warn(lkb);
1901 }
1902
1903 if (do_cancel) {
1904 log_debug(ls, "timeout cancel %x node %d %s",
1905 lkb->lkb_id, lkb->lkb_nodeid, r->res_name);
1906 lkb->lkb_flags &= ~DLM_IFL_WATCH_TIMEWARN;
1907 lkb->lkb_flags |= DLM_IFL_TIMEOUT_CANCEL;
1908 del_timeout(lkb);
1909 _cancel_lock(r, lkb);
1910 }
1911
1912 unlock_rsb(r);
1913 unhold_rsb(r);
1914 dlm_put_lkb(lkb);
1915 }
1916}
1917
1918/* This is only called by dlm_recoverd, and we rely on dlm_ls_stop() stopping
1919 dlm_recoverd before checking/setting ls_recover_begin. */
1920
1921void dlm_adjust_timeouts(struct dlm_ls *ls)
1922{
1923 struct dlm_lkb *lkb;
1924 u64 adj_us = jiffies_to_usecs(jiffies - ls->ls_recover_begin);
1925
1926 ls->ls_recover_begin = 0;
1927 mutex_lock(&ls->ls_timeout_mutex);
1928 list_for_each_entry(lkb, &ls->ls_timeout, lkb_time_list)
1929 lkb->lkb_timestamp = ktime_add_us(lkb->lkb_timestamp, adj_us);
1930 mutex_unlock(&ls->ls_timeout_mutex);
1931
1932 if (!dlm_config.ci_waitwarn_us)
1933 return;
1934
1935 mutex_lock(&ls->ls_waiters_mutex);
1936 list_for_each_entry(lkb, &ls->ls_waiters, lkb_wait_reply) {
1937 if (ktime_to_us(lkb->lkb_wait_time))
1938 lkb->lkb_wait_time = ktime_get();
1939 }
1940 mutex_unlock(&ls->ls_waiters_mutex);
1941}
1942
1943/* lkb is master or local copy */
1944
1945static void set_lvb_lock(struct dlm_rsb *r, struct dlm_lkb *lkb)
1946{
1947 int b, len = r->res_ls->ls_lvblen;
1948
1949 /* b=1 lvb returned to caller
1950 b=0 lvb written to rsb or invalidated
1951 b=-1 do nothing */
1952
1953 b = dlm_lvb_operations[lkb->lkb_grmode + 1][lkb->lkb_rqmode + 1];
1954
1955 if (b == 1) {
1956 if (!lkb->lkb_lvbptr)
1957 return;
1958
1959 if (!(lkb->lkb_exflags & DLM_LKF_VALBLK))
1960 return;
1961
1962 if (!r->res_lvbptr)
1963 return;
1964
1965 memcpy(lkb->lkb_lvbptr, r->res_lvbptr, len);
1966 lkb->lkb_lvbseq = r->res_lvbseq;
1967
1968 } else if (b == 0) {
1969 if (lkb->lkb_exflags & DLM_LKF_IVVALBLK) {
1970 rsb_set_flag(r, RSB_VALNOTVALID);
1971 return;
1972 }
1973
1974 if (!lkb->lkb_lvbptr)
1975 return;
1976
1977 if (!(lkb->lkb_exflags & DLM_LKF_VALBLK))
1978 return;
1979
1980 if (!r->res_lvbptr)
1981 r->res_lvbptr = dlm_allocate_lvb(r->res_ls);
1982
1983 if (!r->res_lvbptr)
1984 return;
1985
1986 memcpy(r->res_lvbptr, lkb->lkb_lvbptr, len);
1987 r->res_lvbseq++;
1988 lkb->lkb_lvbseq = r->res_lvbseq;
1989 rsb_clear_flag(r, RSB_VALNOTVALID);
1990 }
1991
1992 if (rsb_flag(r, RSB_VALNOTVALID))
1993 lkb->lkb_sbflags |= DLM_SBF_VALNOTVALID;
1994}
1995
1996static void set_lvb_unlock(struct dlm_rsb *r, struct dlm_lkb *lkb)
1997{
1998 if (lkb->lkb_grmode < DLM_LOCK_PW)
1999 return;
2000
2001 if (lkb->lkb_exflags & DLM_LKF_IVVALBLK) {
2002 rsb_set_flag(r, RSB_VALNOTVALID);
2003 return;
2004 }
2005
2006 if (!lkb->lkb_lvbptr)
2007 return;
2008
2009 if (!(lkb->lkb_exflags & DLM_LKF_VALBLK))
2010 return;
2011
2012 if (!r->res_lvbptr)
2013 r->res_lvbptr = dlm_allocate_lvb(r->res_ls);
2014
2015 if (!r->res_lvbptr)
2016 return;
2017
2018 memcpy(r->res_lvbptr, lkb->lkb_lvbptr, r->res_ls->ls_lvblen);
2019 r->res_lvbseq++;
2020 rsb_clear_flag(r, RSB_VALNOTVALID);
2021}
2022
2023/* lkb is process copy (pc) */
2024
2025static void set_lvb_lock_pc(struct dlm_rsb *r, struct dlm_lkb *lkb,
2026 struct dlm_message *ms)
2027{
2028 int b;
2029
2030 if (!lkb->lkb_lvbptr)
2031 return;
2032
2033 if (!(lkb->lkb_exflags & DLM_LKF_VALBLK))
2034 return;
2035
2036 b = dlm_lvb_operations[lkb->lkb_grmode + 1][lkb->lkb_rqmode + 1];
2037 if (b == 1) {
2038 int len = receive_extralen(ms);
2039 if (len > r->res_ls->ls_lvblen)
2040 len = r->res_ls->ls_lvblen;
2041 memcpy(lkb->lkb_lvbptr, ms->m_extra, len);
2042 lkb->lkb_lvbseq = ms->m_lvbseq;
2043 }
2044}
2045
2046/* Manipulate lkb's on rsb's convert/granted/waiting queues
2047 remove_lock -- used for unlock, removes lkb from granted
2048 revert_lock -- used for cancel, moves lkb from convert to granted
2049 grant_lock -- used for request and convert, adds lkb to granted or
2050 moves lkb from convert or waiting to granted
2051
2052 Each of these is used for master or local copy lkb's. There is
2053 also a _pc() variation used to make the corresponding change on
2054 a process copy (pc) lkb. */
2055
2056static void _remove_lock(struct dlm_rsb *r, struct dlm_lkb *lkb)
2057{
2058 del_lkb(r, lkb);
2059 lkb->lkb_grmode = DLM_LOCK_IV;
2060 /* this unhold undoes the original ref from create_lkb()
2061 so this leads to the lkb being freed */
2062 unhold_lkb(lkb);
2063}
2064
2065static void remove_lock(struct dlm_rsb *r, struct dlm_lkb *lkb)
2066{
2067 set_lvb_unlock(r, lkb);
2068 _remove_lock(r, lkb);
2069}
2070
2071static void remove_lock_pc(struct dlm_rsb *r, struct dlm_lkb *lkb)
2072{
2073 _remove_lock(r, lkb);
2074}
2075
2076/* returns: 0 did nothing
2077 1 moved lock to granted
2078 -1 removed lock */
2079
2080static int revert_lock(struct dlm_rsb *r, struct dlm_lkb *lkb)
2081{
2082 int rv = 0;
2083
2084 lkb->lkb_rqmode = DLM_LOCK_IV;
2085
2086 switch (lkb->lkb_status) {
2087 case DLM_LKSTS_GRANTED:
2088 break;
2089 case DLM_LKSTS_CONVERT:
2090 move_lkb(r, lkb, DLM_LKSTS_GRANTED);
2091 rv = 1;
2092 break;
2093 case DLM_LKSTS_WAITING:
2094 del_lkb(r, lkb);
2095 lkb->lkb_grmode = DLM_LOCK_IV;
2096 /* this unhold undoes the original ref from create_lkb()
2097 so this leads to the lkb being freed */
2098 unhold_lkb(lkb);
2099 rv = -1;
2100 break;
2101 default:
2102 log_print("invalid status for revert %d", lkb->lkb_status);
2103 }
2104 return rv;
2105}
2106
2107static int revert_lock_pc(struct dlm_rsb *r, struct dlm_lkb *lkb)
2108{
2109 return revert_lock(r, lkb);
2110}
2111
2112static void _grant_lock(struct dlm_rsb *r, struct dlm_lkb *lkb)
2113{
2114 if (lkb->lkb_grmode != lkb->lkb_rqmode) {
2115 lkb->lkb_grmode = lkb->lkb_rqmode;
2116 if (lkb->lkb_status)
2117 move_lkb(r, lkb, DLM_LKSTS_GRANTED);
2118 else
2119 add_lkb(r, lkb, DLM_LKSTS_GRANTED);
2120 }
2121
2122 lkb->lkb_rqmode = DLM_LOCK_IV;
2123 lkb->lkb_highbast = 0;
2124}
2125
2126static void grant_lock(struct dlm_rsb *r, struct dlm_lkb *lkb)
2127{
2128 set_lvb_lock(r, lkb);
2129 _grant_lock(r, lkb);
2130}
2131
2132static void grant_lock_pc(struct dlm_rsb *r, struct dlm_lkb *lkb,
2133 struct dlm_message *ms)
2134{
2135 set_lvb_lock_pc(r, lkb, ms);
2136 _grant_lock(r, lkb);
2137}
2138
2139/* called by grant_pending_locks() which means an async grant message must
2140 be sent to the requesting node in addition to granting the lock if the
2141 lkb belongs to a remote node. */
2142
2143static void grant_lock_pending(struct dlm_rsb *r, struct dlm_lkb *lkb)
2144{
2145 grant_lock(r, lkb);
2146 if (is_master_copy(lkb))
2147 send_grant(r, lkb);
2148 else
2149 queue_cast(r, lkb, 0);
2150}
2151
2152/* The special CONVDEADLK, ALTPR and ALTCW flags allow the master to
2153 change the granted/requested modes. We're munging things accordingly in
2154 the process copy.
2155 CONVDEADLK: our grmode may have been forced down to NL to resolve a
2156 conversion deadlock
2157 ALTPR/ALTCW: our rqmode may have been changed to PR or CW to become
2158 compatible with other granted locks */
2159
2160static void munge_demoted(struct dlm_lkb *lkb)
2161{
2162 if (lkb->lkb_rqmode == DLM_LOCK_IV || lkb->lkb_grmode == DLM_LOCK_IV) {
2163 log_print("munge_demoted %x invalid modes gr %d rq %d",
2164 lkb->lkb_id, lkb->lkb_grmode, lkb->lkb_rqmode);
2165 return;
2166 }
2167
2168 lkb->lkb_grmode = DLM_LOCK_NL;
2169}
2170
2171static void munge_altmode(struct dlm_lkb *lkb, struct dlm_message *ms)
2172{
2173 if (ms->m_type != DLM_MSG_REQUEST_REPLY &&
2174 ms->m_type != DLM_MSG_GRANT) {
2175 log_print("munge_altmode %x invalid reply type %d",
2176 lkb->lkb_id, ms->m_type);
2177 return;
2178 }
2179
2180 if (lkb->lkb_exflags & DLM_LKF_ALTPR)
2181 lkb->lkb_rqmode = DLM_LOCK_PR;
2182 else if (lkb->lkb_exflags & DLM_LKF_ALTCW)
2183 lkb->lkb_rqmode = DLM_LOCK_CW;
2184 else {
2185 log_print("munge_altmode invalid exflags %x", lkb->lkb_exflags);
2186 dlm_print_lkb(lkb);
2187 }
2188}
2189
2190static inline int first_in_list(struct dlm_lkb *lkb, struct list_head *head)
2191{
2192 struct dlm_lkb *first = list_entry(head->next, struct dlm_lkb,
2193 lkb_statequeue);
2194 if (lkb->lkb_id == first->lkb_id)
2195 return 1;
2196
2197 return 0;
2198}
2199
2200/* Check if the given lkb conflicts with another lkb on the queue. */
2201
2202static int queue_conflict(struct list_head *head, struct dlm_lkb *lkb)
2203{
2204 struct dlm_lkb *this;
2205
2206 list_for_each_entry(this, head, lkb_statequeue) {
2207 if (this == lkb)
2208 continue;
2209 if (!modes_compat(this, lkb))
2210 return 1;
2211 }
2212 return 0;
2213}
2214
2215/*
2216 * "A conversion deadlock arises with a pair of lock requests in the converting
2217 * queue for one resource. The granted mode of each lock blocks the requested
2218 * mode of the other lock."
2219 *
2220 * Part 2: if the granted mode of lkb is preventing an earlier lkb in the
2221 * convert queue from being granted, then deadlk/demote lkb.
2222 *
2223 * Example:
2224 * Granted Queue: empty
2225 * Convert Queue: NL->EX (first lock)
2226 * PR->EX (second lock)
2227 *
2228 * The first lock can't be granted because of the granted mode of the second
2229 * lock and the second lock can't be granted because it's not first in the
2230 * list. We either cancel lkb's conversion (PR->EX) and return EDEADLK, or we
2231 * demote the granted mode of lkb (from PR to NL) if it has the CONVDEADLK
2232 * flag set and return DEMOTED in the lksb flags.
2233 *
2234 * Originally, this function detected conv-deadlk in a more limited scope:
2235 * - if !modes_compat(lkb1, lkb2) && !modes_compat(lkb2, lkb1), or
2236 * - if lkb1 was the first entry in the queue (not just earlier), and was
2237 * blocked by the granted mode of lkb2, and there was nothing on the
2238 * granted queue preventing lkb1 from being granted immediately, i.e.
2239 * lkb2 was the only thing preventing lkb1 from being granted.
2240 *
2241 * That second condition meant we'd only say there was conv-deadlk if
2242 * resolving it (by demotion) would lead to the first lock on the convert
2243 * queue being granted right away. It allowed conversion deadlocks to exist
2244 * between locks on the convert queue while they couldn't be granted anyway.
2245 *
2246 * Now, we detect and take action on conversion deadlocks immediately when
2247 * they're created, even if they may not be immediately consequential. If
2248 * lkb1 exists anywhere in the convert queue and lkb2 comes in with a granted
2249 * mode that would prevent lkb1's conversion from being granted, we do a
2250 * deadlk/demote on lkb2 right away and don't let it onto the convert queue.
2251 * I think this means that the lkb_is_ahead condition below should always
2252 * be zero, i.e. there will never be conv-deadlk between two locks that are
2253 * both already on the convert queue.
2254 */
2255
2256static int conversion_deadlock_detect(struct dlm_rsb *r, struct dlm_lkb *lkb2)
2257{
2258 struct dlm_lkb *lkb1;
2259 int lkb_is_ahead = 0;
2260
2261 list_for_each_entry(lkb1, &r->res_convertqueue, lkb_statequeue) {
2262 if (lkb1 == lkb2) {
2263 lkb_is_ahead = 1;
2264 continue;
2265 }
2266
2267 if (!lkb_is_ahead) {
2268 if (!modes_compat(lkb2, lkb1))
2269 return 1;
2270 } else {
2271 if (!modes_compat(lkb2, lkb1) &&
2272 !modes_compat(lkb1, lkb2))
2273 return 1;
2274 }
2275 }
2276 return 0;
2277}
2278
2279/*
2280 * Return 1 if the lock can be granted, 0 otherwise.
2281 * Also detect and resolve conversion deadlocks.
2282 *
2283 * lkb is the lock to be granted
2284 *
2285 * now is 1 if the function is being called in the context of the
2286 * immediate request, it is 0 if called later, after the lock has been
2287 * queued.
2288 *
2289 * recover is 1 if dlm_recover_grant() is trying to grant conversions
2290 * after recovery.
2291 *
2292 * References are from chapter 6 of "VAXcluster Principles" by Roy Davis
2293 */
2294
2295static int _can_be_granted(struct dlm_rsb *r, struct dlm_lkb *lkb, int now,
2296 int recover)
2297{
2298 int8_t conv = (lkb->lkb_grmode != DLM_LOCK_IV);
2299
2300 /*
2301 * 6-10: Version 5.4 introduced an option to address the phenomenon of
2302 * a new request for a NL mode lock being blocked.
2303 *
2304 * 6-11: If the optional EXPEDITE flag is used with the new NL mode
2305 * request, then it would be granted. In essence, the use of this flag
2306 * tells the Lock Manager to expedite theis request by not considering
2307 * what may be in the CONVERTING or WAITING queues... As of this
2308 * writing, the EXPEDITE flag can be used only with new requests for NL
2309 * mode locks. This flag is not valid for conversion requests.
2310 *
2311 * A shortcut. Earlier checks return an error if EXPEDITE is used in a
2312 * conversion or used with a non-NL requested mode. We also know an
2313 * EXPEDITE request is always granted immediately, so now must always
2314 * be 1. The full condition to grant an expedite request: (now &&
2315 * !conv && lkb->rqmode == DLM_LOCK_NL && (flags & EXPEDITE)) can
2316 * therefore be shortened to just checking the flag.
2317 */
2318
2319 if (lkb->lkb_exflags & DLM_LKF_EXPEDITE)
2320 return 1;
2321
2322 /*
2323 * A shortcut. Without this, !queue_conflict(grantqueue, lkb) would be
2324 * added to the remaining conditions.
2325 */
2326
2327 if (queue_conflict(&r->res_grantqueue, lkb))
2328 return 0;
2329
2330 /*
2331 * 6-3: By default, a conversion request is immediately granted if the
2332 * requested mode is compatible with the modes of all other granted
2333 * locks
2334 */
2335
2336 if (queue_conflict(&r->res_convertqueue, lkb))
2337 return 0;
2338
2339 /*
2340 * The RECOVER_GRANT flag means dlm_recover_grant() is granting
2341 * locks for a recovered rsb, on which lkb's have been rebuilt.
2342 * The lkb's may have been rebuilt on the queues in a different
2343 * order than they were in on the previous master. So, granting
2344 * queued conversions in order after recovery doesn't make sense
2345 * since the order hasn't been preserved anyway. The new order
2346 * could also have created a new "in place" conversion deadlock.
2347 * (e.g. old, failed master held granted EX, with PR->EX, NL->EX.
2348 * After recovery, there would be no granted locks, and possibly
2349 * NL->EX, PR->EX, an in-place conversion deadlock.) So, after
2350 * recovery, grant conversions without considering order.
2351 */
2352
2353 if (conv && recover)
2354 return 1;
2355
2356 /*
2357 * 6-5: But the default algorithm for deciding whether to grant or
2358 * queue conversion requests does not by itself guarantee that such
2359 * requests are serviced on a "first come first serve" basis. This, in
2360 * turn, can lead to a phenomenon known as "indefinate postponement".
2361 *
2362 * 6-7: This issue is dealt with by using the optional QUECVT flag with
2363 * the system service employed to request a lock conversion. This flag
2364 * forces certain conversion requests to be queued, even if they are
2365 * compatible with the granted modes of other locks on the same
2366 * resource. Thus, the use of this flag results in conversion requests
2367 * being ordered on a "first come first servce" basis.
2368 *
2369 * DCT: This condition is all about new conversions being able to occur
2370 * "in place" while the lock remains on the granted queue (assuming
2371 * nothing else conflicts.) IOW if QUECVT isn't set, a conversion
2372 * doesn't _have_ to go onto the convert queue where it's processed in
2373 * order. The "now" variable is necessary to distinguish converts
2374 * being received and processed for the first time now, because once a
2375 * convert is moved to the conversion queue the condition below applies
2376 * requiring fifo granting.
2377 */
2378
2379 if (now && conv && !(lkb->lkb_exflags & DLM_LKF_QUECVT))
2380 return 1;
2381
2382 /*
2383 * Even if the convert is compat with all granted locks,
2384 * QUECVT forces it behind other locks on the convert queue.
2385 */
2386
2387 if (now && conv && (lkb->lkb_exflags & DLM_LKF_QUECVT)) {
2388 if (list_empty(&r->res_convertqueue))
2389 return 1;
2390 else
2391 return 0;
2392 }
2393
2394 /*
2395 * The NOORDER flag is set to avoid the standard vms rules on grant
2396 * order.
2397 */
2398
2399 if (lkb->lkb_exflags & DLM_LKF_NOORDER)
2400 return 1;
2401
2402 /*
2403 * 6-3: Once in that queue [CONVERTING], a conversion request cannot be
2404 * granted until all other conversion requests ahead of it are granted
2405 * and/or canceled.
2406 */
2407
2408 if (!now && conv && first_in_list(lkb, &r->res_convertqueue))
2409 return 1;
2410
2411 /*
2412 * 6-4: By default, a new request is immediately granted only if all
2413 * three of the following conditions are satisfied when the request is
2414 * issued:
2415 * - The queue of ungranted conversion requests for the resource is
2416 * empty.
2417 * - The queue of ungranted new requests for the resource is empty.
2418 * - The mode of the new request is compatible with the most
2419 * restrictive mode of all granted locks on the resource.
2420 */
2421
2422 if (now && !conv && list_empty(&r->res_convertqueue) &&
2423 list_empty(&r->res_waitqueue))
2424 return 1;
2425
2426 /*
2427 * 6-4: Once a lock request is in the queue of ungranted new requests,
2428 * it cannot be granted until the queue of ungranted conversion
2429 * requests is empty, all ungranted new requests ahead of it are
2430 * granted and/or canceled, and it is compatible with the granted mode
2431 * of the most restrictive lock granted on the resource.
2432 */
2433
2434 if (!now && !conv && list_empty(&r->res_convertqueue) &&
2435 first_in_list(lkb, &r->res_waitqueue))
2436 return 1;
2437
2438 return 0;
2439}
2440
2441static int can_be_granted(struct dlm_rsb *r, struct dlm_lkb *lkb, int now,
2442 int recover, int *err)
2443{
2444 int rv;
2445 int8_t alt = 0, rqmode = lkb->lkb_rqmode;
2446 int8_t is_convert = (lkb->lkb_grmode != DLM_LOCK_IV);
2447
2448 if (err)
2449 *err = 0;
2450
2451 rv = _can_be_granted(r, lkb, now, recover);
2452 if (rv)
2453 goto out;
2454
2455 /*
2456 * The CONVDEADLK flag is non-standard and tells the dlm to resolve
2457 * conversion deadlocks by demoting grmode to NL, otherwise the dlm
2458 * cancels one of the locks.
2459 */
2460
2461 if (is_convert && can_be_queued(lkb) &&
2462 conversion_deadlock_detect(r, lkb)) {
2463 if (lkb->lkb_exflags & DLM_LKF_CONVDEADLK) {
2464 lkb->lkb_grmode = DLM_LOCK_NL;
2465 lkb->lkb_sbflags |= DLM_SBF_DEMOTED;
2466 } else if (err) {
2467 *err = -EDEADLK;
2468 } else {
2469 log_print("can_be_granted deadlock %x now %d",
2470 lkb->lkb_id, now);
2471 dlm_dump_rsb(r);
2472 }
2473 goto out;
2474 }
2475
2476 /*
2477 * The ALTPR and ALTCW flags are non-standard and tell the dlm to try
2478 * to grant a request in a mode other than the normal rqmode. It's a
2479 * simple way to provide a big optimization to applications that can
2480 * use them.
2481 */
2482
2483 if (rqmode != DLM_LOCK_PR && (lkb->lkb_exflags & DLM_LKF_ALTPR))
2484 alt = DLM_LOCK_PR;
2485 else if (rqmode != DLM_LOCK_CW && (lkb->lkb_exflags & DLM_LKF_ALTCW))
2486 alt = DLM_LOCK_CW;
2487
2488 if (alt) {
2489 lkb->lkb_rqmode = alt;
2490 rv = _can_be_granted(r, lkb, now, 0);
2491 if (rv)
2492 lkb->lkb_sbflags |= DLM_SBF_ALTMODE;
2493 else
2494 lkb->lkb_rqmode = rqmode;
2495 }
2496 out:
2497 return rv;
2498}
2499
2500/* Returns the highest requested mode of all blocked conversions; sets
2501 cw if there's a blocked conversion to DLM_LOCK_CW. */
2502
2503static int grant_pending_convert(struct dlm_rsb *r, int high, int *cw,
2504 unsigned int *count)
2505{
2506 struct dlm_lkb *lkb, *s;
2507 int recover = rsb_flag(r, RSB_RECOVER_GRANT);
2508 int hi, demoted, quit, grant_restart, demote_restart;
2509 int deadlk;
2510
2511 quit = 0;
2512 restart:
2513 grant_restart = 0;
2514 demote_restart = 0;
2515 hi = DLM_LOCK_IV;
2516
2517 list_for_each_entry_safe(lkb, s, &r->res_convertqueue, lkb_statequeue) {
2518 demoted = is_demoted(lkb);
2519 deadlk = 0;
2520
2521 if (can_be_granted(r, lkb, 0, recover, &deadlk)) {
2522 grant_lock_pending(r, lkb);
2523 grant_restart = 1;
2524 if (count)
2525 (*count)++;
2526 continue;
2527 }
2528
2529 if (!demoted && is_demoted(lkb)) {
2530 log_print("WARN: pending demoted %x node %d %s",
2531 lkb->lkb_id, lkb->lkb_nodeid, r->res_name);
2532 demote_restart = 1;
2533 continue;
2534 }
2535
2536 if (deadlk) {
2537 /*
2538 * If DLM_LKB_NODLKWT flag is set and conversion
2539 * deadlock is detected, we request blocking AST and
2540 * down (or cancel) conversion.
2541 */
2542 if (lkb->lkb_exflags & DLM_LKF_NODLCKWT) {
2543 if (lkb->lkb_highbast < lkb->lkb_rqmode) {
2544 queue_bast(r, lkb, lkb->lkb_rqmode);
2545 lkb->lkb_highbast = lkb->lkb_rqmode;
2546 }
2547 } else {
2548 log_print("WARN: pending deadlock %x node %d %s",
2549 lkb->lkb_id, lkb->lkb_nodeid,
2550 r->res_name);
2551 dlm_dump_rsb(r);
2552 }
2553 continue;
2554 }
2555
2556 hi = max_t(int, lkb->lkb_rqmode, hi);
2557
2558 if (cw && lkb->lkb_rqmode == DLM_LOCK_CW)
2559 *cw = 1;
2560 }
2561
2562 if (grant_restart)
2563 goto restart;
2564 if (demote_restart && !quit) {
2565 quit = 1;
2566 goto restart;
2567 }
2568
2569 return max_t(int, high, hi);
2570}
2571
2572static int grant_pending_wait(struct dlm_rsb *r, int high, int *cw,
2573 unsigned int *count)
2574{
2575 struct dlm_lkb *lkb, *s;
2576
2577 list_for_each_entry_safe(lkb, s, &r->res_waitqueue, lkb_statequeue) {
2578 if (can_be_granted(r, lkb, 0, 0, NULL)) {
2579 grant_lock_pending(r, lkb);
2580 if (count)
2581 (*count)++;
2582 } else {
2583 high = max_t(int, lkb->lkb_rqmode, high);
2584 if (lkb->lkb_rqmode == DLM_LOCK_CW)
2585 *cw = 1;
2586 }
2587 }
2588
2589 return high;
2590}
2591
2592/* cw of 1 means there's a lock with a rqmode of DLM_LOCK_CW that's blocked
2593 on either the convert or waiting queue.
2594 high is the largest rqmode of all locks blocked on the convert or
2595 waiting queue. */
2596
2597static int lock_requires_bast(struct dlm_lkb *gr, int high, int cw)
2598{
2599 if (gr->lkb_grmode == DLM_LOCK_PR && cw) {
2600 if (gr->lkb_highbast < DLM_LOCK_EX)
2601 return 1;
2602 return 0;
2603 }
2604
2605 if (gr->lkb_highbast < high &&
2606 !__dlm_compat_matrix[gr->lkb_grmode+1][high+1])
2607 return 1;
2608 return 0;
2609}
2610
2611static void grant_pending_locks(struct dlm_rsb *r, unsigned int *count)
2612{
2613 struct dlm_lkb *lkb, *s;
2614 int high = DLM_LOCK_IV;
2615 int cw = 0;
2616
2617 if (!is_master(r)) {
2618 log_print("grant_pending_locks r nodeid %d", r->res_nodeid);
2619 dlm_dump_rsb(r);
2620 return;
2621 }
2622
2623 high = grant_pending_convert(r, high, &cw, count);
2624 high = grant_pending_wait(r, high, &cw, count);
2625
2626 if (high == DLM_LOCK_IV)
2627 return;
2628
2629 /*
2630 * If there are locks left on the wait/convert queue then send blocking
2631 * ASTs to granted locks based on the largest requested mode (high)
2632 * found above.
2633 */
2634
2635 list_for_each_entry_safe(lkb, s, &r->res_grantqueue, lkb_statequeue) {
2636 if (lkb->lkb_bastfn && lock_requires_bast(lkb, high, cw)) {
2637 if (cw && high == DLM_LOCK_PR &&
2638 lkb->lkb_grmode == DLM_LOCK_PR)
2639 queue_bast(r, lkb, DLM_LOCK_CW);
2640 else
2641 queue_bast(r, lkb, high);
2642 lkb->lkb_highbast = high;
2643 }
2644 }
2645}
2646
2647static int modes_require_bast(struct dlm_lkb *gr, struct dlm_lkb *rq)
2648{
2649 if ((gr->lkb_grmode == DLM_LOCK_PR && rq->lkb_rqmode == DLM_LOCK_CW) ||
2650 (gr->lkb_grmode == DLM_LOCK_CW && rq->lkb_rqmode == DLM_LOCK_PR)) {
2651 if (gr->lkb_highbast < DLM_LOCK_EX)
2652 return 1;
2653 return 0;
2654 }
2655
2656 if (gr->lkb_highbast < rq->lkb_rqmode && !modes_compat(gr, rq))
2657 return 1;
2658 return 0;
2659}
2660
2661static void send_bast_queue(struct dlm_rsb *r, struct list_head *head,
2662 struct dlm_lkb *lkb)
2663{
2664 struct dlm_lkb *gr;
2665
2666 list_for_each_entry(gr, head, lkb_statequeue) {
2667 /* skip self when sending basts to convertqueue */
2668 if (gr == lkb)
2669 continue;
2670 if (gr->lkb_bastfn && modes_require_bast(gr, lkb)) {
2671 queue_bast(r, gr, lkb->lkb_rqmode);
2672 gr->lkb_highbast = lkb->lkb_rqmode;
2673 }
2674 }
2675}
2676
2677static void send_blocking_asts(struct dlm_rsb *r, struct dlm_lkb *lkb)
2678{
2679 send_bast_queue(r, &r->res_grantqueue, lkb);
2680}
2681
2682static void send_blocking_asts_all(struct dlm_rsb *r, struct dlm_lkb *lkb)
2683{
2684 send_bast_queue(r, &r->res_grantqueue, lkb);
2685 send_bast_queue(r, &r->res_convertqueue, lkb);
2686}
2687
2688/* set_master(r, lkb) -- set the master nodeid of a resource
2689
2690 The purpose of this function is to set the nodeid field in the given
2691 lkb using the nodeid field in the given rsb. If the rsb's nodeid is
2692 known, it can just be copied to the lkb and the function will return
2693 0. If the rsb's nodeid is _not_ known, it needs to be looked up
2694 before it can be copied to the lkb.
2695
2696 When the rsb nodeid is being looked up remotely, the initial lkb
2697 causing the lookup is kept on the ls_waiters list waiting for the
2698 lookup reply. Other lkb's waiting for the same rsb lookup are kept
2699 on the rsb's res_lookup list until the master is verified.
2700
2701 Return values:
2702 0: nodeid is set in rsb/lkb and the caller should go ahead and use it
2703 1: the rsb master is not available and the lkb has been placed on
2704 a wait queue
2705*/
2706
2707static int set_master(struct dlm_rsb *r, struct dlm_lkb *lkb)
2708{
2709 int our_nodeid = dlm_our_nodeid();
2710
2711 if (rsb_flag(r, RSB_MASTER_UNCERTAIN)) {
2712 rsb_clear_flag(r, RSB_MASTER_UNCERTAIN);
2713 r->res_first_lkid = lkb->lkb_id;
2714 lkb->lkb_nodeid = r->res_nodeid;
2715 return 0;
2716 }
2717
2718 if (r->res_first_lkid && r->res_first_lkid != lkb->lkb_id) {
2719 list_add_tail(&lkb->lkb_rsb_lookup, &r->res_lookup);
2720 return 1;
2721 }
2722
2723 if (r->res_master_nodeid == our_nodeid) {
2724 lkb->lkb_nodeid = 0;
2725 return 0;
2726 }
2727
2728 if (r->res_master_nodeid) {
2729 lkb->lkb_nodeid = r->res_master_nodeid;
2730 return 0;
2731 }
2732
2733 if (dlm_dir_nodeid(r) == our_nodeid) {
2734 /* This is a somewhat unusual case; find_rsb will usually
2735 have set res_master_nodeid when dir nodeid is local, but
2736 there are cases where we become the dir node after we've
2737 past find_rsb and go through _request_lock again.
2738 confirm_master() or process_lookup_list() needs to be
2739 called after this. */
2740 log_debug(r->res_ls, "set_master %x self master %d dir %d %s",
2741 lkb->lkb_id, r->res_master_nodeid, r->res_dir_nodeid,
2742 r->res_name);
2743 r->res_master_nodeid = our_nodeid;
2744 r->res_nodeid = 0;
2745 lkb->lkb_nodeid = 0;
2746 return 0;
2747 }
2748
2749 wait_pending_remove(r);
2750
2751 r->res_first_lkid = lkb->lkb_id;
2752 send_lookup(r, lkb);
2753 return 1;
2754}
2755
2756static void process_lookup_list(struct dlm_rsb *r)
2757{
2758 struct dlm_lkb *lkb, *safe;
2759
2760 list_for_each_entry_safe(lkb, safe, &r->res_lookup, lkb_rsb_lookup) {
2761 list_del_init(&lkb->lkb_rsb_lookup);
2762 _request_lock(r, lkb);
2763 schedule();
2764 }
2765}
2766
2767/* confirm_master -- confirm (or deny) an rsb's master nodeid */
2768
2769static void confirm_master(struct dlm_rsb *r, int error)
2770{
2771 struct dlm_lkb *lkb;
2772
2773 if (!r->res_first_lkid)
2774 return;
2775
2776 switch (error) {
2777 case 0:
2778 case -EINPROGRESS:
2779 r->res_first_lkid = 0;
2780 process_lookup_list(r);
2781 break;
2782
2783 case -EAGAIN:
2784 case -EBADR:
2785 case -ENOTBLK:
2786 /* the remote request failed and won't be retried (it was
2787 a NOQUEUE, or has been canceled/unlocked); make a waiting
2788 lkb the first_lkid */
2789
2790 r->res_first_lkid = 0;
2791
2792 if (!list_empty(&r->res_lookup)) {
2793 lkb = list_entry(r->res_lookup.next, struct dlm_lkb,
2794 lkb_rsb_lookup);
2795 list_del_init(&lkb->lkb_rsb_lookup);
2796 r->res_first_lkid = lkb->lkb_id;
2797 _request_lock(r, lkb);
2798 }
2799 break;
2800
2801 default:
2802 log_error(r->res_ls, "confirm_master unknown error %d", error);
2803 }
2804}
2805
2806static int set_lock_args(int mode, struct dlm_lksb *lksb, uint32_t flags,
2807 int namelen, unsigned long timeout_cs,
2808 void (*ast) (void *astparam),
2809 void *astparam,
2810 void (*bast) (void *astparam, int mode),
2811 struct dlm_args *args)
2812{
2813 int rv = -EINVAL;
2814
2815 /* check for invalid arg usage */
2816
2817 if (mode < 0 || mode > DLM_LOCK_EX)
2818 goto out;
2819
2820 if (!(flags & DLM_LKF_CONVERT) && (namelen > DLM_RESNAME_MAXLEN))
2821 goto out;
2822
2823 if (flags & DLM_LKF_CANCEL)
2824 goto out;
2825
2826 if (flags & DLM_LKF_QUECVT && !(flags & DLM_LKF_CONVERT))
2827 goto out;
2828
2829 if (flags & DLM_LKF_CONVDEADLK && !(flags & DLM_LKF_CONVERT))
2830 goto out;
2831
2832 if (flags & DLM_LKF_CONVDEADLK && flags & DLM_LKF_NOQUEUE)
2833 goto out;
2834
2835 if (flags & DLM_LKF_EXPEDITE && flags & DLM_LKF_CONVERT)
2836 goto out;
2837
2838 if (flags & DLM_LKF_EXPEDITE && flags & DLM_LKF_QUECVT)
2839 goto out;
2840
2841 if (flags & DLM_LKF_EXPEDITE && flags & DLM_LKF_NOQUEUE)
2842 goto out;
2843
2844 if (flags & DLM_LKF_EXPEDITE && mode != DLM_LOCK_NL)
2845 goto out;
2846
2847 if (!ast || !lksb)
2848 goto out;
2849
2850 if (flags & DLM_LKF_VALBLK && !lksb->sb_lvbptr)
2851 goto out;
2852
2853 if (flags & DLM_LKF_CONVERT && !lksb->sb_lkid)
2854 goto out;
2855
2856 /* these args will be copied to the lkb in validate_lock_args,
2857 it cannot be done now because when converting locks, fields in
2858 an active lkb cannot be modified before locking the rsb */
2859
2860 args->flags = flags;
2861 args->astfn = ast;
2862 args->astparam = astparam;
2863 args->bastfn = bast;
2864 args->timeout = timeout_cs;
2865 args->mode = mode;
2866 args->lksb = lksb;
2867 rv = 0;
2868 out:
2869 return rv;
2870}
2871
2872static int set_unlock_args(uint32_t flags, void *astarg, struct dlm_args *args)
2873{
2874 if (flags & ~(DLM_LKF_CANCEL | DLM_LKF_VALBLK | DLM_LKF_IVVALBLK |
2875 DLM_LKF_FORCEUNLOCK))
2876 return -EINVAL;
2877
2878 if (flags & DLM_LKF_CANCEL && flags & DLM_LKF_FORCEUNLOCK)
2879 return -EINVAL;
2880
2881 args->flags = flags;
2882 args->astparam = astarg;
2883 return 0;
2884}
2885
2886static int validate_lock_args(struct dlm_ls *ls, struct dlm_lkb *lkb,
2887 struct dlm_args *args)
2888{
2889 int rv = -EINVAL;
2890
2891 if (args->flags & DLM_LKF_CONVERT) {
2892 if (lkb->lkb_flags & DLM_IFL_MSTCPY)
2893 goto out;
2894
2895 if (args->flags & DLM_LKF_QUECVT &&
2896 !__quecvt_compat_matrix[lkb->lkb_grmode+1][args->mode+1])
2897 goto out;
2898
2899 rv = -EBUSY;
2900 if (lkb->lkb_status != DLM_LKSTS_GRANTED)
2901 goto out;
2902
2903 if (lkb->lkb_wait_type)
2904 goto out;
2905
2906 if (is_overlap(lkb))
2907 goto out;
2908 }
2909
2910 lkb->lkb_exflags = args->flags;
2911 lkb->lkb_sbflags = 0;
2912 lkb->lkb_astfn = args->astfn;
2913 lkb->lkb_astparam = args->astparam;
2914 lkb->lkb_bastfn = args->bastfn;
2915 lkb->lkb_rqmode = args->mode;
2916 lkb->lkb_lksb = args->lksb;
2917 lkb->lkb_lvbptr = args->lksb->sb_lvbptr;
2918 lkb->lkb_ownpid = (int) current->pid;
2919 lkb->lkb_timeout_cs = args->timeout;
2920 rv = 0;
2921 out:
2922 if (rv)
2923 log_debug(ls, "validate_lock_args %d %x %x %x %d %d %s",
2924 rv, lkb->lkb_id, lkb->lkb_flags, args->flags,
2925 lkb->lkb_status, lkb->lkb_wait_type,
2926 lkb->lkb_resource->res_name);
2927 return rv;
2928}
2929
2930/* when dlm_unlock() sees -EBUSY with CANCEL/FORCEUNLOCK it returns 0
2931 for success */
2932
2933/* note: it's valid for lkb_nodeid/res_nodeid to be -1 when we get here
2934 because there may be a lookup in progress and it's valid to do
2935 cancel/unlockf on it */
2936
2937static int validate_unlock_args(struct dlm_lkb *lkb, struct dlm_args *args)
2938{
2939 struct dlm_ls *ls = lkb->lkb_resource->res_ls;
2940 int rv = -EINVAL;
2941
2942 if (lkb->lkb_flags & DLM_IFL_MSTCPY) {
2943 log_error(ls, "unlock on MSTCPY %x", lkb->lkb_id);
2944 dlm_print_lkb(lkb);
2945 goto out;
2946 }
2947
2948 /* an lkb may still exist even though the lock is EOL'ed due to a
2949 cancel, unlock or failed noqueue request; an app can't use these
2950 locks; return same error as if the lkid had not been found at all */
2951
2952 if (lkb->lkb_flags & DLM_IFL_ENDOFLIFE) {
2953 log_debug(ls, "unlock on ENDOFLIFE %x", lkb->lkb_id);
2954 rv = -ENOENT;
2955 goto out;
2956 }
2957
2958 /* an lkb may be waiting for an rsb lookup to complete where the
2959 lookup was initiated by another lock */
2960
2961 if (!list_empty(&lkb->lkb_rsb_lookup)) {
2962 if (args->flags & (DLM_LKF_CANCEL | DLM_LKF_FORCEUNLOCK)) {
2963 log_debug(ls, "unlock on rsb_lookup %x", lkb->lkb_id);
2964 list_del_init(&lkb->lkb_rsb_lookup);
2965 queue_cast(lkb->lkb_resource, lkb,
2966 args->flags & DLM_LKF_CANCEL ?
2967 -DLM_ECANCEL : -DLM_EUNLOCK);
2968 unhold_lkb(lkb); /* undoes create_lkb() */
2969 }
2970 /* caller changes -EBUSY to 0 for CANCEL and FORCEUNLOCK */
2971 rv = -EBUSY;
2972 goto out;
2973 }
2974
2975 /* cancel not allowed with another cancel/unlock in progress */
2976
2977 if (args->flags & DLM_LKF_CANCEL) {
2978 if (lkb->lkb_exflags & DLM_LKF_CANCEL)
2979 goto out;
2980
2981 if (is_overlap(lkb))
2982 goto out;
2983
2984 /* don't let scand try to do a cancel */
2985 del_timeout(lkb);
2986
2987 if (lkb->lkb_flags & DLM_IFL_RESEND) {
2988 lkb->lkb_flags |= DLM_IFL_OVERLAP_CANCEL;
2989 rv = -EBUSY;
2990 goto out;
2991 }
2992
2993 /* there's nothing to cancel */
2994 if (lkb->lkb_status == DLM_LKSTS_GRANTED &&
2995 !lkb->lkb_wait_type) {
2996 rv = -EBUSY;
2997 goto out;
2998 }
2999
3000 switch (lkb->lkb_wait_type) {
3001 case DLM_MSG_LOOKUP:
3002 case DLM_MSG_REQUEST:
3003 lkb->lkb_flags |= DLM_IFL_OVERLAP_CANCEL;
3004 rv = -EBUSY;
3005 goto out;
3006 case DLM_MSG_UNLOCK:
3007 case DLM_MSG_CANCEL:
3008 goto out;
3009 }
3010 /* add_to_waiters() will set OVERLAP_CANCEL */
3011 goto out_ok;
3012 }
3013
3014 /* do we need to allow a force-unlock if there's a normal unlock
3015 already in progress? in what conditions could the normal unlock
3016 fail such that we'd want to send a force-unlock to be sure? */
3017
3018 if (args->flags & DLM_LKF_FORCEUNLOCK) {
3019 if (lkb->lkb_exflags & DLM_LKF_FORCEUNLOCK)
3020 goto out;
3021
3022 if (is_overlap_unlock(lkb))
3023 goto out;
3024
3025 /* don't let scand try to do a cancel */
3026 del_timeout(lkb);
3027
3028 if (lkb->lkb_flags & DLM_IFL_RESEND) {
3029 lkb->lkb_flags |= DLM_IFL_OVERLAP_UNLOCK;
3030 rv = -EBUSY;
3031 goto out;
3032 }
3033
3034 switch (lkb->lkb_wait_type) {
3035 case DLM_MSG_LOOKUP:
3036 case DLM_MSG_REQUEST:
3037 lkb->lkb_flags |= DLM_IFL_OVERLAP_UNLOCK;
3038 rv = -EBUSY;
3039 goto out;
3040 case DLM_MSG_UNLOCK:
3041 goto out;
3042 }
3043 /* add_to_waiters() will set OVERLAP_UNLOCK */
3044 goto out_ok;
3045 }
3046
3047 /* normal unlock not allowed if there's any op in progress */
3048 rv = -EBUSY;
3049 if (lkb->lkb_wait_type || lkb->lkb_wait_count)
3050 goto out;
3051
3052 out_ok:
3053 /* an overlapping op shouldn't blow away exflags from other op */
3054 lkb->lkb_exflags |= args->flags;
3055 lkb->lkb_sbflags = 0;
3056 lkb->lkb_astparam = args->astparam;
3057 rv = 0;
3058 out:
3059 if (rv)
3060 log_debug(ls, "validate_unlock_args %d %x %x %x %x %d %s", rv,
3061 lkb->lkb_id, lkb->lkb_flags, lkb->lkb_exflags,
3062 args->flags, lkb->lkb_wait_type,
3063 lkb->lkb_resource->res_name);
3064 return rv;
3065}
3066
3067/*
3068 * Four stage 4 varieties:
3069 * do_request(), do_convert(), do_unlock(), do_cancel()
3070 * These are called on the master node for the given lock and
3071 * from the central locking logic.
3072 */
3073
3074static int do_request(struct dlm_rsb *r, struct dlm_lkb *lkb)
3075{
3076 int error = 0;
3077
3078 if (can_be_granted(r, lkb, 1, 0, NULL)) {
3079 grant_lock(r, lkb);
3080 queue_cast(r, lkb, 0);
3081 goto out;
3082 }
3083
3084 if (can_be_queued(lkb)) {
3085 error = -EINPROGRESS;
3086 add_lkb(r, lkb, DLM_LKSTS_WAITING);
3087 add_timeout(lkb);
3088 goto out;
3089 }
3090
3091 error = -EAGAIN;
3092 queue_cast(r, lkb, -EAGAIN);
3093 out:
3094 return error;
3095}
3096
3097static void do_request_effects(struct dlm_rsb *r, struct dlm_lkb *lkb,
3098 int error)
3099{
3100 switch (error) {
3101 case -EAGAIN:
3102 if (force_blocking_asts(lkb))
3103 send_blocking_asts_all(r, lkb);
3104 break;
3105 case -EINPROGRESS:
3106 send_blocking_asts(r, lkb);
3107 break;
3108 }
3109}
3110
3111static int do_convert(struct dlm_rsb *r, struct dlm_lkb *lkb)
3112{
3113 int error = 0;
3114 int deadlk = 0;
3115
3116 /* changing an existing lock may allow others to be granted */
3117
3118 if (can_be_granted(r, lkb, 1, 0, &deadlk)) {
3119 grant_lock(r, lkb);
3120 queue_cast(r, lkb, 0);
3121 goto out;
3122 }
3123
3124 /* can_be_granted() detected that this lock would block in a conversion
3125 deadlock, so we leave it on the granted queue and return EDEADLK in
3126 the ast for the convert. */
3127
3128 if (deadlk && !(lkb->lkb_exflags & DLM_LKF_NODLCKWT)) {
3129 /* it's left on the granted queue */
3130 revert_lock(r, lkb);
3131 queue_cast(r, lkb, -EDEADLK);
3132 error = -EDEADLK;
3133 goto out;
3134 }
3135
3136 /* is_demoted() means the can_be_granted() above set the grmode
3137 to NL, and left us on the granted queue. This auto-demotion
3138 (due to CONVDEADLK) might mean other locks, and/or this lock, are
3139 now grantable. We have to try to grant other converting locks
3140 before we try again to grant this one. */
3141
3142 if (is_demoted(lkb)) {
3143 grant_pending_convert(r, DLM_LOCK_IV, NULL, NULL);
3144 if (_can_be_granted(r, lkb, 1, 0)) {
3145 grant_lock(r, lkb);
3146 queue_cast(r, lkb, 0);
3147 goto out;
3148 }
3149 /* else fall through and move to convert queue */
3150 }
3151
3152 if (can_be_queued(lkb)) {
3153 error = -EINPROGRESS;
3154 del_lkb(r, lkb);
3155 add_lkb(r, lkb, DLM_LKSTS_CONVERT);
3156 add_timeout(lkb);
3157 goto out;
3158 }
3159
3160 error = -EAGAIN;
3161 queue_cast(r, lkb, -EAGAIN);
3162 out:
3163 return error;
3164}
3165
3166static void do_convert_effects(struct dlm_rsb *r, struct dlm_lkb *lkb,
3167 int error)
3168{
3169 switch (error) {
3170 case 0:
3171 grant_pending_locks(r, NULL);
3172 /* grant_pending_locks also sends basts */
3173 break;
3174 case -EAGAIN:
3175 if (force_blocking_asts(lkb))
3176 send_blocking_asts_all(r, lkb);
3177 break;
3178 case -EINPROGRESS:
3179 send_blocking_asts(r, lkb);
3180 break;
3181 }
3182}
3183
3184static int do_unlock(struct dlm_rsb *r, struct dlm_lkb *lkb)
3185{
3186 remove_lock(r, lkb);
3187 queue_cast(r, lkb, -DLM_EUNLOCK);
3188 return -DLM_EUNLOCK;
3189}
3190
3191static void do_unlock_effects(struct dlm_rsb *r, struct dlm_lkb *lkb,
3192 int error)
3193{
3194 grant_pending_locks(r, NULL);
3195}
3196
3197/* returns: 0 did nothing, -DLM_ECANCEL canceled lock */
3198
3199static int do_cancel(struct dlm_rsb *r, struct dlm_lkb *lkb)
3200{
3201 int error;
3202
3203 error = revert_lock(r, lkb);
3204 if (error) {
3205 queue_cast(r, lkb, -DLM_ECANCEL);
3206 return -DLM_ECANCEL;
3207 }
3208 return 0;
3209}
3210
3211static void do_cancel_effects(struct dlm_rsb *r, struct dlm_lkb *lkb,
3212 int error)
3213{
3214 if (error)
3215 grant_pending_locks(r, NULL);
3216}
3217
3218/*
3219 * Four stage 3 varieties:
3220 * _request_lock(), _convert_lock(), _unlock_lock(), _cancel_lock()
3221 */
3222
3223/* add a new lkb to a possibly new rsb, called by requesting process */
3224
3225static int _request_lock(struct dlm_rsb *r, struct dlm_lkb *lkb)
3226{
3227 int error;
3228
3229 /* set_master: sets lkb nodeid from r */
3230
3231 error = set_master(r, lkb);
3232 if (error < 0)
3233 goto out;
3234 if (error) {
3235 error = 0;
3236 goto out;
3237 }
3238
3239 if (is_remote(r)) {
3240 /* receive_request() calls do_request() on remote node */
3241 error = send_request(r, lkb);
3242 } else {
3243 error = do_request(r, lkb);
3244 /* for remote locks the request_reply is sent
3245 between do_request and do_request_effects */
3246 do_request_effects(r, lkb, error);
3247 }
3248 out:
3249 return error;
3250}
3251
3252/* change some property of an existing lkb, e.g. mode */
3253
3254static int _convert_lock(struct dlm_rsb *r, struct dlm_lkb *lkb)
3255{
3256 int error;
3257
3258 if (is_remote(r)) {
3259 /* receive_convert() calls do_convert() on remote node */
3260 error = send_convert(r, lkb);
3261 } else {
3262 error = do_convert(r, lkb);
3263 /* for remote locks the convert_reply is sent
3264 between do_convert and do_convert_effects */
3265 do_convert_effects(r, lkb, error);
3266 }
3267
3268 return error;
3269}
3270
3271/* remove an existing lkb from the granted queue */
3272
3273static int _unlock_lock(struct dlm_rsb *r, struct dlm_lkb *lkb)
3274{
3275 int error;
3276
3277 if (is_remote(r)) {
3278 /* receive_unlock() calls do_unlock() on remote node */
3279 error = send_unlock(r, lkb);
3280 } else {
3281 error = do_unlock(r, lkb);
3282 /* for remote locks the unlock_reply is sent
3283 between do_unlock and do_unlock_effects */
3284 do_unlock_effects(r, lkb, error);
3285 }
3286
3287 return error;
3288}
3289
3290/* remove an existing lkb from the convert or wait queue */
3291
3292static int _cancel_lock(struct dlm_rsb *r, struct dlm_lkb *lkb)
3293{
3294 int error;
3295
3296 if (is_remote(r)) {
3297 /* receive_cancel() calls do_cancel() on remote node */
3298 error = send_cancel(r, lkb);
3299 } else {
3300 error = do_cancel(r, lkb);
3301 /* for remote locks the cancel_reply is sent
3302 between do_cancel and do_cancel_effects */
3303 do_cancel_effects(r, lkb, error);
3304 }
3305
3306 return error;
3307}
3308
3309/*
3310 * Four stage 2 varieties:
3311 * request_lock(), convert_lock(), unlock_lock(), cancel_lock()
3312 */
3313
3314static int request_lock(struct dlm_ls *ls, struct dlm_lkb *lkb, char *name,
3315 int len, struct dlm_args *args)
3316{
3317 struct dlm_rsb *r;
3318 int error;
3319
3320 error = validate_lock_args(ls, lkb, args);
3321 if (error)
3322 return error;
3323
3324 error = find_rsb(ls, name, len, 0, R_REQUEST, &r);
3325 if (error)
3326 return error;
3327
3328 lock_rsb(r);
3329
3330 attach_lkb(r, lkb);
3331 lkb->lkb_lksb->sb_lkid = lkb->lkb_id;
3332
3333 error = _request_lock(r, lkb);
3334
3335 unlock_rsb(r);
3336 put_rsb(r);
3337 return error;
3338}
3339
3340static int convert_lock(struct dlm_ls *ls, struct dlm_lkb *lkb,
3341 struct dlm_args *args)
3342{
3343 struct dlm_rsb *r;
3344 int error;
3345
3346 r = lkb->lkb_resource;
3347
3348 hold_rsb(r);
3349 lock_rsb(r);
3350
3351 error = validate_lock_args(ls, lkb, args);
3352 if (error)
3353 goto out;
3354
3355 error = _convert_lock(r, lkb);
3356 out:
3357 unlock_rsb(r);
3358 put_rsb(r);
3359 return error;
3360}
3361
3362static int unlock_lock(struct dlm_ls *ls, struct dlm_lkb *lkb,
3363 struct dlm_args *args)
3364{
3365 struct dlm_rsb *r;
3366 int error;
3367
3368 r = lkb->lkb_resource;
3369
3370 hold_rsb(r);
3371 lock_rsb(r);
3372
3373 error = validate_unlock_args(lkb, args);
3374 if (error)
3375 goto out;
3376
3377 error = _unlock_lock(r, lkb);
3378 out:
3379 unlock_rsb(r);
3380 put_rsb(r);
3381 return error;
3382}
3383
3384static int cancel_lock(struct dlm_ls *ls, struct dlm_lkb *lkb,
3385 struct dlm_args *args)
3386{
3387 struct dlm_rsb *r;
3388 int error;
3389
3390 r = lkb->lkb_resource;
3391
3392 hold_rsb(r);
3393 lock_rsb(r);
3394
3395 error = validate_unlock_args(lkb, args);
3396 if (error)
3397 goto out;
3398
3399 error = _cancel_lock(r, lkb);
3400 out:
3401 unlock_rsb(r);
3402 put_rsb(r);
3403 return error;
3404}
3405
3406/*
3407 * Two stage 1 varieties: dlm_lock() and dlm_unlock()
3408 */
3409
3410int dlm_lock(dlm_lockspace_t *lockspace,
3411 int mode,
3412 struct dlm_lksb *lksb,
3413 uint32_t flags,
3414 void *name,
3415 unsigned int namelen,
3416 uint32_t parent_lkid,
3417 void (*ast) (void *astarg),
3418 void *astarg,
3419 void (*bast) (void *astarg, int mode))
3420{
3421 struct dlm_ls *ls;
3422 struct dlm_lkb *lkb;
3423 struct dlm_args args;
3424 int error, convert = flags & DLM_LKF_CONVERT;
3425
3426 ls = dlm_find_lockspace_local(lockspace);
3427 if (!ls)
3428 return -EINVAL;
3429
3430 dlm_lock_recovery(ls);
3431
3432 if (convert)
3433 error = find_lkb(ls, lksb->sb_lkid, &lkb);
3434 else
3435 error = create_lkb(ls, &lkb);
3436
3437 if (error)
3438 goto out;
3439
3440 error = set_lock_args(mode, lksb, flags, namelen, 0, ast,
3441 astarg, bast, &args);
3442 if (error)
3443 goto out_put;
3444
3445 if (convert)
3446 error = convert_lock(ls, lkb, &args);
3447 else
3448 error = request_lock(ls, lkb, name, namelen, &args);
3449
3450 if (error == -EINPROGRESS)
3451 error = 0;
3452 out_put:
3453 if (convert || error)
3454 __put_lkb(ls, lkb);
3455 if (error == -EAGAIN || error == -EDEADLK)
3456 error = 0;
3457 out:
3458 dlm_unlock_recovery(ls);
3459 dlm_put_lockspace(ls);
3460 return error;
3461}
3462
3463int dlm_unlock(dlm_lockspace_t *lockspace,
3464 uint32_t lkid,
3465 uint32_t flags,
3466 struct dlm_lksb *lksb,
3467 void *astarg)
3468{
3469 struct dlm_ls *ls;
3470 struct dlm_lkb *lkb;
3471 struct dlm_args args;
3472 int error;
3473
3474 ls = dlm_find_lockspace_local(lockspace);
3475 if (!ls)
3476 return -EINVAL;
3477
3478 dlm_lock_recovery(ls);
3479
3480 error = find_lkb(ls, lkid, &lkb);
3481 if (error)
3482 goto out;
3483
3484 error = set_unlock_args(flags, astarg, &args);
3485 if (error)
3486 goto out_put;
3487
3488 if (flags & DLM_LKF_CANCEL)
3489 error = cancel_lock(ls, lkb, &args);
3490 else
3491 error = unlock_lock(ls, lkb, &args);
3492
3493 if (error == -DLM_EUNLOCK || error == -DLM_ECANCEL)
3494 error = 0;
3495 if (error == -EBUSY && (flags & (DLM_LKF_CANCEL | DLM_LKF_FORCEUNLOCK)))
3496 error = 0;
3497 out_put:
3498 dlm_put_lkb(lkb);
3499 out:
3500 dlm_unlock_recovery(ls);
3501 dlm_put_lockspace(ls);
3502 return error;
3503}
3504
3505/*
3506 * send/receive routines for remote operations and replies
3507 *
3508 * send_args
3509 * send_common
3510 * send_request receive_request
3511 * send_convert receive_convert
3512 * send_unlock receive_unlock
3513 * send_cancel receive_cancel
3514 * send_grant receive_grant
3515 * send_bast receive_bast
3516 * send_lookup receive_lookup
3517 * send_remove receive_remove
3518 *
3519 * send_common_reply
3520 * receive_request_reply send_request_reply
3521 * receive_convert_reply send_convert_reply
3522 * receive_unlock_reply send_unlock_reply
3523 * receive_cancel_reply send_cancel_reply
3524 * receive_lookup_reply send_lookup_reply
3525 */
3526
3527static int _create_message(struct dlm_ls *ls, int mb_len,
3528 int to_nodeid, int mstype,
3529 struct dlm_message **ms_ret,
3530 struct dlm_mhandle **mh_ret)
3531{
3532 struct dlm_message *ms;
3533 struct dlm_mhandle *mh;
3534 char *mb;
3535
3536 /* get_buffer gives us a message handle (mh) that we need to
3537 pass into midcomms_commit and a message buffer (mb) that we
3538 write our data into */
3539
3540 mh = dlm_midcomms_get_mhandle(to_nodeid, mb_len, GFP_NOFS, &mb);
3541 if (!mh)
3542 return -ENOBUFS;
3543
3544 ms = (struct dlm_message *) mb;
3545
3546 ms->m_header.h_version = (DLM_HEADER_MAJOR | DLM_HEADER_MINOR);
3547 ms->m_header.u.h_lockspace = ls->ls_global_id;
3548 ms->m_header.h_nodeid = dlm_our_nodeid();
3549 ms->m_header.h_length = mb_len;
3550 ms->m_header.h_cmd = DLM_MSG;
3551
3552 ms->m_type = mstype;
3553
3554 *mh_ret = mh;
3555 *ms_ret = ms;
3556 return 0;
3557}
3558
3559static int create_message(struct dlm_rsb *r, struct dlm_lkb *lkb,
3560 int to_nodeid, int mstype,
3561 struct dlm_message **ms_ret,
3562 struct dlm_mhandle **mh_ret)
3563{
3564 int mb_len = sizeof(struct dlm_message);
3565
3566 switch (mstype) {
3567 case DLM_MSG_REQUEST:
3568 case DLM_MSG_LOOKUP:
3569 case DLM_MSG_REMOVE:
3570 mb_len += r->res_length;
3571 break;
3572 case DLM_MSG_CONVERT:
3573 case DLM_MSG_UNLOCK:
3574 case DLM_MSG_REQUEST_REPLY:
3575 case DLM_MSG_CONVERT_REPLY:
3576 case DLM_MSG_GRANT:
3577 if (lkb && lkb->lkb_lvbptr)
3578 mb_len += r->res_ls->ls_lvblen;
3579 break;
3580 }
3581
3582 return _create_message(r->res_ls, mb_len, to_nodeid, mstype,
3583 ms_ret, mh_ret);
3584}
3585
3586/* further lowcomms enhancements or alternate implementations may make
3587 the return value from this function useful at some point */
3588
3589static int send_message(struct dlm_mhandle *mh, struct dlm_message *ms)
3590{
3591 dlm_message_out(ms);
3592 dlm_midcomms_commit_mhandle(mh);
3593 return 0;
3594}
3595
3596static void send_args(struct dlm_rsb *r, struct dlm_lkb *lkb,
3597 struct dlm_message *ms)
3598{
3599 ms->m_nodeid = lkb->lkb_nodeid;
3600 ms->m_pid = lkb->lkb_ownpid;
3601 ms->m_lkid = lkb->lkb_id;
3602 ms->m_remid = lkb->lkb_remid;
3603 ms->m_exflags = lkb->lkb_exflags;
3604 ms->m_sbflags = lkb->lkb_sbflags;
3605 ms->m_flags = lkb->lkb_flags;
3606 ms->m_lvbseq = lkb->lkb_lvbseq;
3607 ms->m_status = lkb->lkb_status;
3608 ms->m_grmode = lkb->lkb_grmode;
3609 ms->m_rqmode = lkb->lkb_rqmode;
3610 ms->m_hash = r->res_hash;
3611
3612 /* m_result and m_bastmode are set from function args,
3613 not from lkb fields */
3614
3615 if (lkb->lkb_bastfn)
3616 ms->m_asts |= DLM_CB_BAST;
3617 if (lkb->lkb_astfn)
3618 ms->m_asts |= DLM_CB_CAST;
3619
3620 /* compare with switch in create_message; send_remove() doesn't
3621 use send_args() */
3622
3623 switch (ms->m_type) {
3624 case DLM_MSG_REQUEST:
3625 case DLM_MSG_LOOKUP:
3626 memcpy(ms->m_extra, r->res_name, r->res_length);
3627 break;
3628 case DLM_MSG_CONVERT:
3629 case DLM_MSG_UNLOCK:
3630 case DLM_MSG_REQUEST_REPLY:
3631 case DLM_MSG_CONVERT_REPLY:
3632 case DLM_MSG_GRANT:
3633 if (!lkb->lkb_lvbptr)
3634 break;
3635 memcpy(ms->m_extra, lkb->lkb_lvbptr, r->res_ls->ls_lvblen);
3636 break;
3637 }
3638}
3639
3640static int send_common(struct dlm_rsb *r, struct dlm_lkb *lkb, int mstype)
3641{
3642 struct dlm_message *ms;
3643 struct dlm_mhandle *mh;
3644 int to_nodeid, error;
3645
3646 to_nodeid = r->res_nodeid;
3647
3648 error = add_to_waiters(lkb, mstype, to_nodeid);
3649 if (error)
3650 return error;
3651
3652 error = create_message(r, lkb, to_nodeid, mstype, &ms, &mh);
3653 if (error)
3654 goto fail;
3655
3656 send_args(r, lkb, ms);
3657
3658 error = send_message(mh, ms);
3659 if (error)
3660 goto fail;
3661 return 0;
3662
3663 fail:
3664 remove_from_waiters(lkb, msg_reply_type(mstype));
3665 return error;
3666}
3667
3668static int send_request(struct dlm_rsb *r, struct dlm_lkb *lkb)
3669{
3670 return send_common(r, lkb, DLM_MSG_REQUEST);
3671}
3672
3673static int send_convert(struct dlm_rsb *r, struct dlm_lkb *lkb)
3674{
3675 int error;
3676
3677 error = send_common(r, lkb, DLM_MSG_CONVERT);
3678
3679 /* down conversions go without a reply from the master */
3680 if (!error && down_conversion(lkb)) {
3681 remove_from_waiters(lkb, DLM_MSG_CONVERT_REPLY);
3682 r->res_ls->ls_stub_ms.m_flags = DLM_IFL_STUB_MS;
3683 r->res_ls->ls_stub_ms.m_type = DLM_MSG_CONVERT_REPLY;
3684 r->res_ls->ls_stub_ms.m_result = 0;
3685 __receive_convert_reply(r, lkb, &r->res_ls->ls_stub_ms);
3686 }
3687
3688 return error;
3689}
3690
3691/* FIXME: if this lkb is the only lock we hold on the rsb, then set
3692 MASTER_UNCERTAIN to force the next request on the rsb to confirm
3693 that the master is still correct. */
3694
3695static int send_unlock(struct dlm_rsb *r, struct dlm_lkb *lkb)
3696{
3697 return send_common(r, lkb, DLM_MSG_UNLOCK);
3698}
3699
3700static int send_cancel(struct dlm_rsb *r, struct dlm_lkb *lkb)
3701{
3702 return send_common(r, lkb, DLM_MSG_CANCEL);
3703}
3704
3705static int send_grant(struct dlm_rsb *r, struct dlm_lkb *lkb)
3706{
3707 struct dlm_message *ms;
3708 struct dlm_mhandle *mh;
3709 int to_nodeid, error;
3710
3711 to_nodeid = lkb->lkb_nodeid;
3712
3713 error = create_message(r, lkb, to_nodeid, DLM_MSG_GRANT, &ms, &mh);
3714 if (error)
3715 goto out;
3716
3717 send_args(r, lkb, ms);
3718
3719 ms->m_result = 0;
3720
3721 error = send_message(mh, ms);
3722 out:
3723 return error;
3724}
3725
3726static int send_bast(struct dlm_rsb *r, struct dlm_lkb *lkb, int mode)
3727{
3728 struct dlm_message *ms;
3729 struct dlm_mhandle *mh;
3730 int to_nodeid, error;
3731
3732 to_nodeid = lkb->lkb_nodeid;
3733
3734 error = create_message(r, NULL, to_nodeid, DLM_MSG_BAST, &ms, &mh);
3735 if (error)
3736 goto out;
3737
3738 send_args(r, lkb, ms);
3739
3740 ms->m_bastmode = mode;
3741
3742 error = send_message(mh, ms);
3743 out:
3744 return error;
3745}
3746
3747static int send_lookup(struct dlm_rsb *r, struct dlm_lkb *lkb)
3748{
3749 struct dlm_message *ms;
3750 struct dlm_mhandle *mh;
3751 int to_nodeid, error;
3752
3753 to_nodeid = dlm_dir_nodeid(r);
3754
3755 error = add_to_waiters(lkb, DLM_MSG_LOOKUP, to_nodeid);
3756 if (error)
3757 return error;
3758
3759 error = create_message(r, NULL, to_nodeid, DLM_MSG_LOOKUP, &ms, &mh);
3760 if (error)
3761 goto fail;
3762
3763 send_args(r, lkb, ms);
3764
3765 error = send_message(mh, ms);
3766 if (error)
3767 goto fail;
3768 return 0;
3769
3770 fail:
3771 remove_from_waiters(lkb, DLM_MSG_LOOKUP_REPLY);
3772 return error;
3773}
3774
3775static int send_remove(struct dlm_rsb *r)
3776{
3777 struct dlm_message *ms;
3778 struct dlm_mhandle *mh;
3779 int to_nodeid, error;
3780
3781 to_nodeid = dlm_dir_nodeid(r);
3782
3783 error = create_message(r, NULL, to_nodeid, DLM_MSG_REMOVE, &ms, &mh);
3784 if (error)
3785 goto out;
3786
3787 memcpy(ms->m_extra, r->res_name, r->res_length);
3788 ms->m_hash = r->res_hash;
3789
3790 error = send_message(mh, ms);
3791 out:
3792 return error;
3793}
3794
3795static int send_common_reply(struct dlm_rsb *r, struct dlm_lkb *lkb,
3796 int mstype, int rv)
3797{
3798 struct dlm_message *ms;
3799 struct dlm_mhandle *mh;
3800 int to_nodeid, error;
3801
3802 to_nodeid = lkb->lkb_nodeid;
3803
3804 error = create_message(r, lkb, to_nodeid, mstype, &ms, &mh);
3805 if (error)
3806 goto out;
3807
3808 send_args(r, lkb, ms);
3809
3810 ms->m_result = rv;
3811
3812 error = send_message(mh, ms);
3813 out:
3814 return error;
3815}
3816
3817static int send_request_reply(struct dlm_rsb *r, struct dlm_lkb *lkb, int rv)
3818{
3819 return send_common_reply(r, lkb, DLM_MSG_REQUEST_REPLY, rv);
3820}
3821
3822static int send_convert_reply(struct dlm_rsb *r, struct dlm_lkb *lkb, int rv)
3823{
3824 return send_common_reply(r, lkb, DLM_MSG_CONVERT_REPLY, rv);
3825}
3826
3827static int send_unlock_reply(struct dlm_rsb *r, struct dlm_lkb *lkb, int rv)
3828{
3829 return send_common_reply(r, lkb, DLM_MSG_UNLOCK_REPLY, rv);
3830}
3831
3832static int send_cancel_reply(struct dlm_rsb *r, struct dlm_lkb *lkb, int rv)
3833{
3834 return send_common_reply(r, lkb, DLM_MSG_CANCEL_REPLY, rv);
3835}
3836
3837static int send_lookup_reply(struct dlm_ls *ls, struct dlm_message *ms_in,
3838 int ret_nodeid, int rv)
3839{
3840 struct dlm_rsb *r = &ls->ls_stub_rsb;
3841 struct dlm_message *ms;
3842 struct dlm_mhandle *mh;
3843 int error, nodeid = ms_in->m_header.h_nodeid;
3844
3845 error = create_message(r, NULL, nodeid, DLM_MSG_LOOKUP_REPLY, &ms, &mh);
3846 if (error)
3847 goto out;
3848
3849 ms->m_lkid = ms_in->m_lkid;
3850 ms->m_result = rv;
3851 ms->m_nodeid = ret_nodeid;
3852
3853 error = send_message(mh, ms);
3854 out:
3855 return error;
3856}
3857
3858/* which args we save from a received message depends heavily on the type
3859 of message, unlike the send side where we can safely send everything about
3860 the lkb for any type of message */
3861
3862static void receive_flags(struct dlm_lkb *lkb, struct dlm_message *ms)
3863{
3864 lkb->lkb_exflags = ms->m_exflags;
3865 lkb->lkb_sbflags = ms->m_sbflags;
3866 lkb->lkb_flags = (lkb->lkb_flags & 0xFFFF0000) |
3867 (ms->m_flags & 0x0000FFFF);
3868}
3869
3870static void receive_flags_reply(struct dlm_lkb *lkb, struct dlm_message *ms)
3871{
3872 if (ms->m_flags == DLM_IFL_STUB_MS)
3873 return;
3874
3875 lkb->lkb_sbflags = ms->m_sbflags;
3876 lkb->lkb_flags = (lkb->lkb_flags & 0xFFFF0000) |
3877 (ms->m_flags & 0x0000FFFF);
3878}
3879
3880static int receive_extralen(struct dlm_message *ms)
3881{
3882 return (ms->m_header.h_length - sizeof(struct dlm_message));
3883}
3884
3885static int receive_lvb(struct dlm_ls *ls, struct dlm_lkb *lkb,
3886 struct dlm_message *ms)
3887{
3888 int len;
3889
3890 if (lkb->lkb_exflags & DLM_LKF_VALBLK) {
3891 if (!lkb->lkb_lvbptr)
3892 lkb->lkb_lvbptr = dlm_allocate_lvb(ls);
3893 if (!lkb->lkb_lvbptr)
3894 return -ENOMEM;
3895 len = receive_extralen(ms);
3896 if (len > ls->ls_lvblen)
3897 len = ls->ls_lvblen;
3898 memcpy(lkb->lkb_lvbptr, ms->m_extra, len);
3899 }
3900 return 0;
3901}
3902
3903static void fake_bastfn(void *astparam, int mode)
3904{
3905 log_print("fake_bastfn should not be called");
3906}
3907
3908static void fake_astfn(void *astparam)
3909{
3910 log_print("fake_astfn should not be called");
3911}
3912
3913static int receive_request_args(struct dlm_ls *ls, struct dlm_lkb *lkb,
3914 struct dlm_message *ms)
3915{
3916 lkb->lkb_nodeid = ms->m_header.h_nodeid;
3917 lkb->lkb_ownpid = ms->m_pid;
3918 lkb->lkb_remid = ms->m_lkid;
3919 lkb->lkb_grmode = DLM_LOCK_IV;
3920 lkb->lkb_rqmode = ms->m_rqmode;
3921
3922 lkb->lkb_bastfn = (ms->m_asts & DLM_CB_BAST) ? &fake_bastfn : NULL;
3923 lkb->lkb_astfn = (ms->m_asts & DLM_CB_CAST) ? &fake_astfn : NULL;
3924
3925 if (lkb->lkb_exflags & DLM_LKF_VALBLK) {
3926 /* lkb was just created so there won't be an lvb yet */
3927 lkb->lkb_lvbptr = dlm_allocate_lvb(ls);
3928 if (!lkb->lkb_lvbptr)
3929 return -ENOMEM;
3930 }
3931
3932 return 0;
3933}
3934
3935static int receive_convert_args(struct dlm_ls *ls, struct dlm_lkb *lkb,
3936 struct dlm_message *ms)
3937{
3938 if (lkb->lkb_status != DLM_LKSTS_GRANTED)
3939 return -EBUSY;
3940
3941 if (receive_lvb(ls, lkb, ms))
3942 return -ENOMEM;
3943
3944 lkb->lkb_rqmode = ms->m_rqmode;
3945 lkb->lkb_lvbseq = ms->m_lvbseq;
3946
3947 return 0;
3948}
3949
3950static int receive_unlock_args(struct dlm_ls *ls, struct dlm_lkb *lkb,
3951 struct dlm_message *ms)
3952{
3953 if (receive_lvb(ls, lkb, ms))
3954 return -ENOMEM;
3955 return 0;
3956}
3957
3958/* We fill in the stub-lkb fields with the info that send_xxxx_reply()
3959 uses to send a reply and that the remote end uses to process the reply. */
3960
3961static void setup_stub_lkb(struct dlm_ls *ls, struct dlm_message *ms)
3962{
3963 struct dlm_lkb *lkb = &ls->ls_stub_lkb;
3964 lkb->lkb_nodeid = ms->m_header.h_nodeid;
3965 lkb->lkb_remid = ms->m_lkid;
3966}
3967
3968/* This is called after the rsb is locked so that we can safely inspect
3969 fields in the lkb. */
3970
3971static int validate_message(struct dlm_lkb *lkb, struct dlm_message *ms)
3972{
3973 int from = ms->m_header.h_nodeid;
3974 int error = 0;
3975
3976 switch (ms->m_type) {
3977 case DLM_MSG_CONVERT:
3978 case DLM_MSG_UNLOCK:
3979 case DLM_MSG_CANCEL:
3980 if (!is_master_copy(lkb) || lkb->lkb_nodeid != from)
3981 error = -EINVAL;
3982 break;
3983
3984 case DLM_MSG_CONVERT_REPLY:
3985 case DLM_MSG_UNLOCK_REPLY:
3986 case DLM_MSG_CANCEL_REPLY:
3987 case DLM_MSG_GRANT:
3988 case DLM_MSG_BAST:
3989 if (!is_process_copy(lkb) || lkb->lkb_nodeid != from)
3990 error = -EINVAL;
3991 break;
3992
3993 case DLM_MSG_REQUEST_REPLY:
3994 if (!is_process_copy(lkb))
3995 error = -EINVAL;
3996 else if (lkb->lkb_nodeid != -1 && lkb->lkb_nodeid != from)
3997 error = -EINVAL;
3998 break;
3999
4000 default:
4001 error = -EINVAL;
4002 }
4003
4004 if (error)
4005 log_error(lkb->lkb_resource->res_ls,
4006 "ignore invalid message %d from %d %x %x %x %d",
4007 ms->m_type, from, lkb->lkb_id, lkb->lkb_remid,
4008 lkb->lkb_flags, lkb->lkb_nodeid);
4009 return error;
4010}
4011
4012static void send_repeat_remove(struct dlm_ls *ls, char *ms_name, int len)
4013{
4014 char name[DLM_RESNAME_MAXLEN + 1];
4015 struct dlm_message *ms;
4016 struct dlm_mhandle *mh;
4017 struct dlm_rsb *r;
4018 uint32_t hash, b;
4019 int rv, dir_nodeid;
4020
4021 memset(name, 0, sizeof(name));
4022 memcpy(name, ms_name, len);
4023
4024 hash = jhash(name, len, 0);
4025 b = hash & (ls->ls_rsbtbl_size - 1);
4026
4027 dir_nodeid = dlm_hash2nodeid(ls, hash);
4028
4029 log_error(ls, "send_repeat_remove dir %d %s", dir_nodeid, name);
4030
4031 spin_lock(&ls->ls_rsbtbl[b].lock);
4032 rv = dlm_search_rsb_tree(&ls->ls_rsbtbl[b].keep, name, len, &r);
4033 if (!rv) {
4034 spin_unlock(&ls->ls_rsbtbl[b].lock);
4035 log_error(ls, "repeat_remove on keep %s", name);
4036 return;
4037 }
4038
4039 rv = dlm_search_rsb_tree(&ls->ls_rsbtbl[b].toss, name, len, &r);
4040 if (!rv) {
4041 spin_unlock(&ls->ls_rsbtbl[b].lock);
4042 log_error(ls, "repeat_remove on toss %s", name);
4043 return;
4044 }
4045
4046 /* use ls->remove_name2 to avoid conflict with shrink? */
4047
4048 spin_lock(&ls->ls_remove_spin);
4049 ls->ls_remove_len = len;
4050 memcpy(ls->ls_remove_name, name, DLM_RESNAME_MAXLEN);
4051 spin_unlock(&ls->ls_remove_spin);
4052 spin_unlock(&ls->ls_rsbtbl[b].lock);
4053
4054 rv = _create_message(ls, sizeof(struct dlm_message) + len,
4055 dir_nodeid, DLM_MSG_REMOVE, &ms, &mh);
4056 if (rv)
4057 return;
4058
4059 memcpy(ms->m_extra, name, len);
4060 ms->m_hash = hash;
4061
4062 send_message(mh, ms);
4063
4064 spin_lock(&ls->ls_remove_spin);
4065 ls->ls_remove_len = 0;
4066 memset(ls->ls_remove_name, 0, DLM_RESNAME_MAXLEN);
4067 spin_unlock(&ls->ls_remove_spin);
4068}
4069
4070static int receive_request(struct dlm_ls *ls, struct dlm_message *ms)
4071{
4072 struct dlm_lkb *lkb;
4073 struct dlm_rsb *r;
4074 int from_nodeid;
4075 int error, namelen = 0;
4076
4077 from_nodeid = ms->m_header.h_nodeid;
4078
4079 error = create_lkb(ls, &lkb);
4080 if (error)
4081 goto fail;
4082
4083 receive_flags(lkb, ms);
4084 lkb->lkb_flags |= DLM_IFL_MSTCPY;
4085 error = receive_request_args(ls, lkb, ms);
4086 if (error) {
4087 __put_lkb(ls, lkb);
4088 goto fail;
4089 }
4090
4091 /* The dir node is the authority on whether we are the master
4092 for this rsb or not, so if the master sends us a request, we should
4093 recreate the rsb if we've destroyed it. This race happens when we
4094 send a remove message to the dir node at the same time that the dir
4095 node sends us a request for the rsb. */
4096
4097 namelen = receive_extralen(ms);
4098
4099 error = find_rsb(ls, ms->m_extra, namelen, from_nodeid,
4100 R_RECEIVE_REQUEST, &r);
4101 if (error) {
4102 __put_lkb(ls, lkb);
4103 goto fail;
4104 }
4105
4106 lock_rsb(r);
4107
4108 if (r->res_master_nodeid != dlm_our_nodeid()) {
4109 error = validate_master_nodeid(ls, r, from_nodeid);
4110 if (error) {
4111 unlock_rsb(r);
4112 put_rsb(r);
4113 __put_lkb(ls, lkb);
4114 goto fail;
4115 }
4116 }
4117
4118 attach_lkb(r, lkb);
4119 error = do_request(r, lkb);
4120 send_request_reply(r, lkb, error);
4121 do_request_effects(r, lkb, error);
4122
4123 unlock_rsb(r);
4124 put_rsb(r);
4125
4126 if (error == -EINPROGRESS)
4127 error = 0;
4128 if (error)
4129 dlm_put_lkb(lkb);
4130 return 0;
4131
4132 fail:
4133 /* TODO: instead of returning ENOTBLK, add the lkb to res_lookup
4134 and do this receive_request again from process_lookup_list once
4135 we get the lookup reply. This would avoid a many repeated
4136 ENOTBLK request failures when the lookup reply designating us
4137 as master is delayed. */
4138
4139 /* We could repeatedly return -EBADR here if our send_remove() is
4140 delayed in being sent/arriving/being processed on the dir node.
4141 Another node would repeatedly lookup up the master, and the dir
4142 node would continue returning our nodeid until our send_remove
4143 took effect.
4144
4145 We send another remove message in case our previous send_remove
4146 was lost/ignored/missed somehow. */
4147
4148 if (error != -ENOTBLK) {
4149 log_limit(ls, "receive_request %x from %d %d",
4150 ms->m_lkid, from_nodeid, error);
4151 }
4152
4153 if (namelen && error == -EBADR) {
4154 send_repeat_remove(ls, ms->m_extra, namelen);
4155 msleep(1000);
4156 }
4157
4158 setup_stub_lkb(ls, ms);
4159 send_request_reply(&ls->ls_stub_rsb, &ls->ls_stub_lkb, error);
4160 return error;
4161}
4162
4163static int receive_convert(struct dlm_ls *ls, struct dlm_message *ms)
4164{
4165 struct dlm_lkb *lkb;
4166 struct dlm_rsb *r;
4167 int error, reply = 1;
4168
4169 error = find_lkb(ls, ms->m_remid, &lkb);
4170 if (error)
4171 goto fail;
4172
4173 if (lkb->lkb_remid != ms->m_lkid) {
4174 log_error(ls, "receive_convert %x remid %x recover_seq %llu "
4175 "remote %d %x", lkb->lkb_id, lkb->lkb_remid,
4176 (unsigned long long)lkb->lkb_recover_seq,
4177 ms->m_header.h_nodeid, ms->m_lkid);
4178 error = -ENOENT;
4179 dlm_put_lkb(lkb);
4180 goto fail;
4181 }
4182
4183 r = lkb->lkb_resource;
4184
4185 hold_rsb(r);
4186 lock_rsb(r);
4187
4188 error = validate_message(lkb, ms);
4189 if (error)
4190 goto out;
4191
4192 receive_flags(lkb, ms);
4193
4194 error = receive_convert_args(ls, lkb, ms);
4195 if (error) {
4196 send_convert_reply(r, lkb, error);
4197 goto out;
4198 }
4199
4200 reply = !down_conversion(lkb);
4201
4202 error = do_convert(r, lkb);
4203 if (reply)
4204 send_convert_reply(r, lkb, error);
4205 do_convert_effects(r, lkb, error);
4206 out:
4207 unlock_rsb(r);
4208 put_rsb(r);
4209 dlm_put_lkb(lkb);
4210 return 0;
4211
4212 fail:
4213 setup_stub_lkb(ls, ms);
4214 send_convert_reply(&ls->ls_stub_rsb, &ls->ls_stub_lkb, error);
4215 return error;
4216}
4217
4218static int receive_unlock(struct dlm_ls *ls, struct dlm_message *ms)
4219{
4220 struct dlm_lkb *lkb;
4221 struct dlm_rsb *r;
4222 int error;
4223
4224 error = find_lkb(ls, ms->m_remid, &lkb);
4225 if (error)
4226 goto fail;
4227
4228 if (lkb->lkb_remid != ms->m_lkid) {
4229 log_error(ls, "receive_unlock %x remid %x remote %d %x",
4230 lkb->lkb_id, lkb->lkb_remid,
4231 ms->m_header.h_nodeid, ms->m_lkid);
4232 error = -ENOENT;
4233 dlm_put_lkb(lkb);
4234 goto fail;
4235 }
4236
4237 r = lkb->lkb_resource;
4238
4239 hold_rsb(r);
4240 lock_rsb(r);
4241
4242 error = validate_message(lkb, ms);
4243 if (error)
4244 goto out;
4245
4246 receive_flags(lkb, ms);
4247
4248 error = receive_unlock_args(ls, lkb, ms);
4249 if (error) {
4250 send_unlock_reply(r, lkb, error);
4251 goto out;
4252 }
4253
4254 error = do_unlock(r, lkb);
4255 send_unlock_reply(r, lkb, error);
4256 do_unlock_effects(r, lkb, error);
4257 out:
4258 unlock_rsb(r);
4259 put_rsb(r);
4260 dlm_put_lkb(lkb);
4261 return 0;
4262
4263 fail:
4264 setup_stub_lkb(ls, ms);
4265 send_unlock_reply(&ls->ls_stub_rsb, &ls->ls_stub_lkb, error);
4266 return error;
4267}
4268
4269static int receive_cancel(struct dlm_ls *ls, struct dlm_message *ms)
4270{
4271 struct dlm_lkb *lkb;
4272 struct dlm_rsb *r;
4273 int error;
4274
4275 error = find_lkb(ls, ms->m_remid, &lkb);
4276 if (error)
4277 goto fail;
4278
4279 receive_flags(lkb, ms);
4280
4281 r = lkb->lkb_resource;
4282
4283 hold_rsb(r);
4284 lock_rsb(r);
4285
4286 error = validate_message(lkb, ms);
4287 if (error)
4288 goto out;
4289
4290 error = do_cancel(r, lkb);
4291 send_cancel_reply(r, lkb, error);
4292 do_cancel_effects(r, lkb, error);
4293 out:
4294 unlock_rsb(r);
4295 put_rsb(r);
4296 dlm_put_lkb(lkb);
4297 return 0;
4298
4299 fail:
4300 setup_stub_lkb(ls, ms);
4301 send_cancel_reply(&ls->ls_stub_rsb, &ls->ls_stub_lkb, error);
4302 return error;
4303}
4304
4305static int receive_grant(struct dlm_ls *ls, struct dlm_message *ms)
4306{
4307 struct dlm_lkb *lkb;
4308 struct dlm_rsb *r;
4309 int error;
4310
4311 error = find_lkb(ls, ms->m_remid, &lkb);
4312 if (error)
4313 return error;
4314
4315 r = lkb->lkb_resource;
4316
4317 hold_rsb(r);
4318 lock_rsb(r);
4319
4320 error = validate_message(lkb, ms);
4321 if (error)
4322 goto out;
4323
4324 receive_flags_reply(lkb, ms);
4325 if (is_altmode(lkb))
4326 munge_altmode(lkb, ms);
4327 grant_lock_pc(r, lkb, ms);
4328 queue_cast(r, lkb, 0);
4329 out:
4330 unlock_rsb(r);
4331 put_rsb(r);
4332 dlm_put_lkb(lkb);
4333 return 0;
4334}
4335
4336static int receive_bast(struct dlm_ls *ls, struct dlm_message *ms)
4337{
4338 struct dlm_lkb *lkb;
4339 struct dlm_rsb *r;
4340 int error;
4341
4342 error = find_lkb(ls, ms->m_remid, &lkb);
4343 if (error)
4344 return error;
4345
4346 r = lkb->lkb_resource;
4347
4348 hold_rsb(r);
4349 lock_rsb(r);
4350
4351 error = validate_message(lkb, ms);
4352 if (error)
4353 goto out;
4354
4355 queue_bast(r, lkb, ms->m_bastmode);
4356 lkb->lkb_highbast = ms->m_bastmode;
4357 out:
4358 unlock_rsb(r);
4359 put_rsb(r);
4360 dlm_put_lkb(lkb);
4361 return 0;
4362}
4363
4364static void receive_lookup(struct dlm_ls *ls, struct dlm_message *ms)
4365{
4366 int len, error, ret_nodeid, from_nodeid, our_nodeid;
4367
4368 from_nodeid = ms->m_header.h_nodeid;
4369 our_nodeid = dlm_our_nodeid();
4370
4371 len = receive_extralen(ms);
4372
4373 error = dlm_master_lookup(ls, from_nodeid, ms->m_extra, len, 0,
4374 &ret_nodeid, NULL);
4375
4376 /* Optimization: we're master so treat lookup as a request */
4377 if (!error && ret_nodeid == our_nodeid) {
4378 receive_request(ls, ms);
4379 return;
4380 }
4381 send_lookup_reply(ls, ms, ret_nodeid, error);
4382}
4383
4384static void receive_remove(struct dlm_ls *ls, struct dlm_message *ms)
4385{
4386 char name[DLM_RESNAME_MAXLEN+1];
4387 struct dlm_rsb *r;
4388 uint32_t hash, b;
4389 int rv, len, dir_nodeid, from_nodeid;
4390
4391 from_nodeid = ms->m_header.h_nodeid;
4392
4393 len = receive_extralen(ms);
4394
4395 if (len > DLM_RESNAME_MAXLEN) {
4396 log_error(ls, "receive_remove from %d bad len %d",
4397 from_nodeid, len);
4398 return;
4399 }
4400
4401 dir_nodeid = dlm_hash2nodeid(ls, ms->m_hash);
4402 if (dir_nodeid != dlm_our_nodeid()) {
4403 log_error(ls, "receive_remove from %d bad nodeid %d",
4404 from_nodeid, dir_nodeid);
4405 return;
4406 }
4407
4408 /* Look for name on rsbtbl.toss, if it's there, kill it.
4409 If it's on rsbtbl.keep, it's being used, and we should ignore this
4410 message. This is an expected race between the dir node sending a
4411 request to the master node at the same time as the master node sends
4412 a remove to the dir node. The resolution to that race is for the
4413 dir node to ignore the remove message, and the master node to
4414 recreate the master rsb when it gets a request from the dir node for
4415 an rsb it doesn't have. */
4416
4417 memset(name, 0, sizeof(name));
4418 memcpy(name, ms->m_extra, len);
4419
4420 hash = jhash(name, len, 0);
4421 b = hash & (ls->ls_rsbtbl_size - 1);
4422
4423 spin_lock(&ls->ls_rsbtbl[b].lock);
4424
4425 rv = dlm_search_rsb_tree(&ls->ls_rsbtbl[b].toss, name, len, &r);
4426 if (rv) {
4427 /* verify the rsb is on keep list per comment above */
4428 rv = dlm_search_rsb_tree(&ls->ls_rsbtbl[b].keep, name, len, &r);
4429 if (rv) {
4430 /* should not happen */
4431 log_error(ls, "receive_remove from %d not found %s",
4432 from_nodeid, name);
4433 spin_unlock(&ls->ls_rsbtbl[b].lock);
4434 return;
4435 }
4436 if (r->res_master_nodeid != from_nodeid) {
4437 /* should not happen */
4438 log_error(ls, "receive_remove keep from %d master %d",
4439 from_nodeid, r->res_master_nodeid);
4440 dlm_print_rsb(r);
4441 spin_unlock(&ls->ls_rsbtbl[b].lock);
4442 return;
4443 }
4444
4445 log_debug(ls, "receive_remove from %d master %d first %x %s",
4446 from_nodeid, r->res_master_nodeid, r->res_first_lkid,
4447 name);
4448 spin_unlock(&ls->ls_rsbtbl[b].lock);
4449 return;
4450 }
4451
4452 if (r->res_master_nodeid != from_nodeid) {
4453 log_error(ls, "receive_remove toss from %d master %d",
4454 from_nodeid, r->res_master_nodeid);
4455 dlm_print_rsb(r);
4456 spin_unlock(&ls->ls_rsbtbl[b].lock);
4457 return;
4458 }
4459
4460 if (kref_put(&r->res_ref, kill_rsb)) {
4461 rb_erase(&r->res_hashnode, &ls->ls_rsbtbl[b].toss);
4462 spin_unlock(&ls->ls_rsbtbl[b].lock);
4463 dlm_free_rsb(r);
4464 } else {
4465 log_error(ls, "receive_remove from %d rsb ref error",
4466 from_nodeid);
4467 dlm_print_rsb(r);
4468 spin_unlock(&ls->ls_rsbtbl[b].lock);
4469 }
4470}
4471
4472static void receive_purge(struct dlm_ls *ls, struct dlm_message *ms)
4473{
4474 do_purge(ls, ms->m_nodeid, ms->m_pid);
4475}
4476
4477static int receive_request_reply(struct dlm_ls *ls, struct dlm_message *ms)
4478{
4479 struct dlm_lkb *lkb;
4480 struct dlm_rsb *r;
4481 int error, mstype, result;
4482 int from_nodeid = ms->m_header.h_nodeid;
4483
4484 error = find_lkb(ls, ms->m_remid, &lkb);
4485 if (error)
4486 return error;
4487
4488 r = lkb->lkb_resource;
4489 hold_rsb(r);
4490 lock_rsb(r);
4491
4492 error = validate_message(lkb, ms);
4493 if (error)
4494 goto out;
4495
4496 mstype = lkb->lkb_wait_type;
4497 error = remove_from_waiters(lkb, DLM_MSG_REQUEST_REPLY);
4498 if (error) {
4499 log_error(ls, "receive_request_reply %x remote %d %x result %d",
4500 lkb->lkb_id, from_nodeid, ms->m_lkid, ms->m_result);
4501 dlm_dump_rsb(r);
4502 goto out;
4503 }
4504
4505 /* Optimization: the dir node was also the master, so it took our
4506 lookup as a request and sent request reply instead of lookup reply */
4507 if (mstype == DLM_MSG_LOOKUP) {
4508 r->res_master_nodeid = from_nodeid;
4509 r->res_nodeid = from_nodeid;
4510 lkb->lkb_nodeid = from_nodeid;
4511 }
4512
4513 /* this is the value returned from do_request() on the master */
4514 result = ms->m_result;
4515
4516 switch (result) {
4517 case -EAGAIN:
4518 /* request would block (be queued) on remote master */
4519 queue_cast(r, lkb, -EAGAIN);
4520 confirm_master(r, -EAGAIN);
4521 unhold_lkb(lkb); /* undoes create_lkb() */
4522 break;
4523
4524 case -EINPROGRESS:
4525 case 0:
4526 /* request was queued or granted on remote master */
4527 receive_flags_reply(lkb, ms);
4528 lkb->lkb_remid = ms->m_lkid;
4529 if (is_altmode(lkb))
4530 munge_altmode(lkb, ms);
4531 if (result) {
4532 add_lkb(r, lkb, DLM_LKSTS_WAITING);
4533 add_timeout(lkb);
4534 } else {
4535 grant_lock_pc(r, lkb, ms);
4536 queue_cast(r, lkb, 0);
4537 }
4538 confirm_master(r, result);
4539 break;
4540
4541 case -EBADR:
4542 case -ENOTBLK:
4543 /* find_rsb failed to find rsb or rsb wasn't master */
4544 log_limit(ls, "receive_request_reply %x from %d %d "
4545 "master %d dir %d first %x %s", lkb->lkb_id,
4546 from_nodeid, result, r->res_master_nodeid,
4547 r->res_dir_nodeid, r->res_first_lkid, r->res_name);
4548
4549 if (r->res_dir_nodeid != dlm_our_nodeid() &&
4550 r->res_master_nodeid != dlm_our_nodeid()) {
4551 /* cause _request_lock->set_master->send_lookup */
4552 r->res_master_nodeid = 0;
4553 r->res_nodeid = -1;
4554 lkb->lkb_nodeid = -1;
4555 }
4556
4557 if (is_overlap(lkb)) {
4558 /* we'll ignore error in cancel/unlock reply */
4559 queue_cast_overlap(r, lkb);
4560 confirm_master(r, result);
4561 unhold_lkb(lkb); /* undoes create_lkb() */
4562 } else {
4563 _request_lock(r, lkb);
4564
4565 if (r->res_master_nodeid == dlm_our_nodeid())
4566 confirm_master(r, 0);
4567 }
4568 break;
4569
4570 default:
4571 log_error(ls, "receive_request_reply %x error %d",
4572 lkb->lkb_id, result);
4573 }
4574
4575 if (is_overlap_unlock(lkb) && (result == 0 || result == -EINPROGRESS)) {
4576 log_debug(ls, "receive_request_reply %x result %d unlock",
4577 lkb->lkb_id, result);
4578 lkb->lkb_flags &= ~DLM_IFL_OVERLAP_UNLOCK;
4579 lkb->lkb_flags &= ~DLM_IFL_OVERLAP_CANCEL;
4580 send_unlock(r, lkb);
4581 } else if (is_overlap_cancel(lkb) && (result == -EINPROGRESS)) {
4582 log_debug(ls, "receive_request_reply %x cancel", lkb->lkb_id);
4583 lkb->lkb_flags &= ~DLM_IFL_OVERLAP_UNLOCK;
4584 lkb->lkb_flags &= ~DLM_IFL_OVERLAP_CANCEL;
4585 send_cancel(r, lkb);
4586 } else {
4587 lkb->lkb_flags &= ~DLM_IFL_OVERLAP_CANCEL;
4588 lkb->lkb_flags &= ~DLM_IFL_OVERLAP_UNLOCK;
4589 }
4590 out:
4591 unlock_rsb(r);
4592 put_rsb(r);
4593 dlm_put_lkb(lkb);
4594 return 0;
4595}
4596
4597static void __receive_convert_reply(struct dlm_rsb *r, struct dlm_lkb *lkb,
4598 struct dlm_message *ms)
4599{
4600 /* this is the value returned from do_convert() on the master */
4601 switch (ms->m_result) {
4602 case -EAGAIN:
4603 /* convert would block (be queued) on remote master */
4604 queue_cast(r, lkb, -EAGAIN);
4605 break;
4606
4607 case -EDEADLK:
4608 receive_flags_reply(lkb, ms);
4609 revert_lock_pc(r, lkb);
4610 queue_cast(r, lkb, -EDEADLK);
4611 break;
4612
4613 case -EINPROGRESS:
4614 /* convert was queued on remote master */
4615 receive_flags_reply(lkb, ms);
4616 if (is_demoted(lkb))
4617 munge_demoted(lkb);
4618 del_lkb(r, lkb);
4619 add_lkb(r, lkb, DLM_LKSTS_CONVERT);
4620 add_timeout(lkb);
4621 break;
4622
4623 case 0:
4624 /* convert was granted on remote master */
4625 receive_flags_reply(lkb, ms);
4626 if (is_demoted(lkb))
4627 munge_demoted(lkb);
4628 grant_lock_pc(r, lkb, ms);
4629 queue_cast(r, lkb, 0);
4630 break;
4631
4632 default:
4633 log_error(r->res_ls, "receive_convert_reply %x remote %d %x %d",
4634 lkb->lkb_id, ms->m_header.h_nodeid, ms->m_lkid,
4635 ms->m_result);
4636 dlm_print_rsb(r);
4637 dlm_print_lkb(lkb);
4638 }
4639}
4640
4641static void _receive_convert_reply(struct dlm_lkb *lkb, struct dlm_message *ms)
4642{
4643 struct dlm_rsb *r = lkb->lkb_resource;
4644 int error;
4645
4646 hold_rsb(r);
4647 lock_rsb(r);
4648
4649 error = validate_message(lkb, ms);
4650 if (error)
4651 goto out;
4652
4653 /* stub reply can happen with waiters_mutex held */
4654 error = remove_from_waiters_ms(lkb, ms);
4655 if (error)
4656 goto out;
4657
4658 __receive_convert_reply(r, lkb, ms);
4659 out:
4660 unlock_rsb(r);
4661 put_rsb(r);
4662}
4663
4664static int receive_convert_reply(struct dlm_ls *ls, struct dlm_message *ms)
4665{
4666 struct dlm_lkb *lkb;
4667 int error;
4668
4669 error = find_lkb(ls, ms->m_remid, &lkb);
4670 if (error)
4671 return error;
4672
4673 _receive_convert_reply(lkb, ms);
4674 dlm_put_lkb(lkb);
4675 return 0;
4676}
4677
4678static void _receive_unlock_reply(struct dlm_lkb *lkb, struct dlm_message *ms)
4679{
4680 struct dlm_rsb *r = lkb->lkb_resource;
4681 int error;
4682
4683 hold_rsb(r);
4684 lock_rsb(r);
4685
4686 error = validate_message(lkb, ms);
4687 if (error)
4688 goto out;
4689
4690 /* stub reply can happen with waiters_mutex held */
4691 error = remove_from_waiters_ms(lkb, ms);
4692 if (error)
4693 goto out;
4694
4695 /* this is the value returned from do_unlock() on the master */
4696
4697 switch (ms->m_result) {
4698 case -DLM_EUNLOCK:
4699 receive_flags_reply(lkb, ms);
4700 remove_lock_pc(r, lkb);
4701 queue_cast(r, lkb, -DLM_EUNLOCK);
4702 break;
4703 case -ENOENT:
4704 break;
4705 default:
4706 log_error(r->res_ls, "receive_unlock_reply %x error %d",
4707 lkb->lkb_id, ms->m_result);
4708 }
4709 out:
4710 unlock_rsb(r);
4711 put_rsb(r);
4712}
4713
4714static int receive_unlock_reply(struct dlm_ls *ls, struct dlm_message *ms)
4715{
4716 struct dlm_lkb *lkb;
4717 int error;
4718
4719 error = find_lkb(ls, ms->m_remid, &lkb);
4720 if (error)
4721 return error;
4722
4723 _receive_unlock_reply(lkb, ms);
4724 dlm_put_lkb(lkb);
4725 return 0;
4726}
4727
4728static void _receive_cancel_reply(struct dlm_lkb *lkb, struct dlm_message *ms)
4729{
4730 struct dlm_rsb *r = lkb->lkb_resource;
4731 int error;
4732
4733 hold_rsb(r);
4734 lock_rsb(r);
4735
4736 error = validate_message(lkb, ms);
4737 if (error)
4738 goto out;
4739
4740 /* stub reply can happen with waiters_mutex held */
4741 error = remove_from_waiters_ms(lkb, ms);
4742 if (error)
4743 goto out;
4744
4745 /* this is the value returned from do_cancel() on the master */
4746
4747 switch (ms->m_result) {
4748 case -DLM_ECANCEL:
4749 receive_flags_reply(lkb, ms);
4750 revert_lock_pc(r, lkb);
4751 queue_cast(r, lkb, -DLM_ECANCEL);
4752 break;
4753 case 0:
4754 break;
4755 default:
4756 log_error(r->res_ls, "receive_cancel_reply %x error %d",
4757 lkb->lkb_id, ms->m_result);
4758 }
4759 out:
4760 unlock_rsb(r);
4761 put_rsb(r);
4762}
4763
4764static int receive_cancel_reply(struct dlm_ls *ls, struct dlm_message *ms)
4765{
4766 struct dlm_lkb *lkb;
4767 int error;
4768
4769 error = find_lkb(ls, ms->m_remid, &lkb);
4770 if (error)
4771 return error;
4772
4773 _receive_cancel_reply(lkb, ms);
4774 dlm_put_lkb(lkb);
4775 return 0;
4776}
4777
4778static void receive_lookup_reply(struct dlm_ls *ls, struct dlm_message *ms)
4779{
4780 struct dlm_lkb *lkb;
4781 struct dlm_rsb *r;
4782 int error, ret_nodeid;
4783 int do_lookup_list = 0;
4784
4785 error = find_lkb(ls, ms->m_lkid, &lkb);
4786 if (error) {
4787 log_error(ls, "receive_lookup_reply no lkid %x", ms->m_lkid);
4788 return;
4789 }
4790
4791 /* ms->m_result is the value returned by dlm_master_lookup on dir node
4792 FIXME: will a non-zero error ever be returned? */
4793
4794 r = lkb->lkb_resource;
4795 hold_rsb(r);
4796 lock_rsb(r);
4797
4798 error = remove_from_waiters(lkb, DLM_MSG_LOOKUP_REPLY);
4799 if (error)
4800 goto out;
4801
4802 ret_nodeid = ms->m_nodeid;
4803
4804 /* We sometimes receive a request from the dir node for this
4805 rsb before we've received the dir node's loookup_reply for it.
4806 The request from the dir node implies we're the master, so we set
4807 ourself as master in receive_request_reply, and verify here that
4808 we are indeed the master. */
4809
4810 if (r->res_master_nodeid && (r->res_master_nodeid != ret_nodeid)) {
4811 /* This should never happen */
4812 log_error(ls, "receive_lookup_reply %x from %d ret %d "
4813 "master %d dir %d our %d first %x %s",
4814 lkb->lkb_id, ms->m_header.h_nodeid, ret_nodeid,
4815 r->res_master_nodeid, r->res_dir_nodeid,
4816 dlm_our_nodeid(), r->res_first_lkid, r->res_name);
4817 }
4818
4819 if (ret_nodeid == dlm_our_nodeid()) {
4820 r->res_master_nodeid = ret_nodeid;
4821 r->res_nodeid = 0;
4822 do_lookup_list = 1;
4823 r->res_first_lkid = 0;
4824 } else if (ret_nodeid == -1) {
4825 /* the remote node doesn't believe it's the dir node */
4826 log_error(ls, "receive_lookup_reply %x from %d bad ret_nodeid",
4827 lkb->lkb_id, ms->m_header.h_nodeid);
4828 r->res_master_nodeid = 0;
4829 r->res_nodeid = -1;
4830 lkb->lkb_nodeid = -1;
4831 } else {
4832 /* set_master() will set lkb_nodeid from r */
4833 r->res_master_nodeid = ret_nodeid;
4834 r->res_nodeid = ret_nodeid;
4835 }
4836
4837 if (is_overlap(lkb)) {
4838 log_debug(ls, "receive_lookup_reply %x unlock %x",
4839 lkb->lkb_id, lkb->lkb_flags);
4840 queue_cast_overlap(r, lkb);
4841 unhold_lkb(lkb); /* undoes create_lkb() */
4842 goto out_list;
4843 }
4844
4845 _request_lock(r, lkb);
4846
4847 out_list:
4848 if (do_lookup_list)
4849 process_lookup_list(r);
4850 out:
4851 unlock_rsb(r);
4852 put_rsb(r);
4853 dlm_put_lkb(lkb);
4854}
4855
4856static void _receive_message(struct dlm_ls *ls, struct dlm_message *ms,
4857 uint32_t saved_seq)
4858{
4859 int error = 0, noent = 0;
4860
4861 if (!dlm_is_member(ls, ms->m_header.h_nodeid)) {
4862 log_limit(ls, "receive %d from non-member %d %x %x %d",
4863 ms->m_type, ms->m_header.h_nodeid, ms->m_lkid,
4864 ms->m_remid, ms->m_result);
4865 return;
4866 }
4867
4868 switch (ms->m_type) {
4869
4870 /* messages sent to a master node */
4871
4872 case DLM_MSG_REQUEST:
4873 error = receive_request(ls, ms);
4874 break;
4875
4876 case DLM_MSG_CONVERT:
4877 error = receive_convert(ls, ms);
4878 break;
4879
4880 case DLM_MSG_UNLOCK:
4881 error = receive_unlock(ls, ms);
4882 break;
4883
4884 case DLM_MSG_CANCEL:
4885 noent = 1;
4886 error = receive_cancel(ls, ms);
4887 break;
4888
4889 /* messages sent from a master node (replies to above) */
4890
4891 case DLM_MSG_REQUEST_REPLY:
4892 error = receive_request_reply(ls, ms);
4893 break;
4894
4895 case DLM_MSG_CONVERT_REPLY:
4896 error = receive_convert_reply(ls, ms);
4897 break;
4898
4899 case DLM_MSG_UNLOCK_REPLY:
4900 error = receive_unlock_reply(ls, ms);
4901 break;
4902
4903 case DLM_MSG_CANCEL_REPLY:
4904 error = receive_cancel_reply(ls, ms);
4905 break;
4906
4907 /* messages sent from a master node (only two types of async msg) */
4908
4909 case DLM_MSG_GRANT:
4910 noent = 1;
4911 error = receive_grant(ls, ms);
4912 break;
4913
4914 case DLM_MSG_BAST:
4915 noent = 1;
4916 error = receive_bast(ls, ms);
4917 break;
4918
4919 /* messages sent to a dir node */
4920
4921 case DLM_MSG_LOOKUP:
4922 receive_lookup(ls, ms);
4923 break;
4924
4925 case DLM_MSG_REMOVE:
4926 receive_remove(ls, ms);
4927 break;
4928
4929 /* messages sent from a dir node (remove has no reply) */
4930
4931 case DLM_MSG_LOOKUP_REPLY:
4932 receive_lookup_reply(ls, ms);
4933 break;
4934
4935 /* other messages */
4936
4937 case DLM_MSG_PURGE:
4938 receive_purge(ls, ms);
4939 break;
4940
4941 default:
4942 log_error(ls, "unknown message type %d", ms->m_type);
4943 }
4944
4945 /*
4946 * When checking for ENOENT, we're checking the result of
4947 * find_lkb(m_remid):
4948 *
4949 * The lock id referenced in the message wasn't found. This may
4950 * happen in normal usage for the async messages and cancel, so
4951 * only use log_debug for them.
4952 *
4953 * Some errors are expected and normal.
4954 */
4955
4956 if (error == -ENOENT && noent) {
4957 log_debug(ls, "receive %d no %x remote %d %x saved_seq %u",
4958 ms->m_type, ms->m_remid, ms->m_header.h_nodeid,
4959 ms->m_lkid, saved_seq);
4960 } else if (error == -ENOENT) {
4961 log_error(ls, "receive %d no %x remote %d %x saved_seq %u",
4962 ms->m_type, ms->m_remid, ms->m_header.h_nodeid,
4963 ms->m_lkid, saved_seq);
4964
4965 if (ms->m_type == DLM_MSG_CONVERT)
4966 dlm_dump_rsb_hash(ls, ms->m_hash);
4967 }
4968
4969 if (error == -EINVAL) {
4970 log_error(ls, "receive %d inval from %d lkid %x remid %x "
4971 "saved_seq %u",
4972 ms->m_type, ms->m_header.h_nodeid,
4973 ms->m_lkid, ms->m_remid, saved_seq);
4974 }
4975}
4976
4977/* If the lockspace is in recovery mode (locking stopped), then normal
4978 messages are saved on the requestqueue for processing after recovery is
4979 done. When not in recovery mode, we wait for dlm_recoverd to drain saved
4980 messages off the requestqueue before we process new ones. This occurs right
4981 after recovery completes when we transition from saving all messages on
4982 requestqueue, to processing all the saved messages, to processing new
4983 messages as they arrive. */
4984
4985static void dlm_receive_message(struct dlm_ls *ls, struct dlm_message *ms,
4986 int nodeid)
4987{
4988 if (dlm_locking_stopped(ls)) {
4989 /* If we were a member of this lockspace, left, and rejoined,
4990 other nodes may still be sending us messages from the
4991 lockspace generation before we left. */
4992 if (!ls->ls_generation) {
4993 log_limit(ls, "receive %d from %d ignore old gen",
4994 ms->m_type, nodeid);
4995 return;
4996 }
4997
4998 dlm_add_requestqueue(ls, nodeid, ms);
4999 } else {
5000 dlm_wait_requestqueue(ls);
5001 _receive_message(ls, ms, 0);
5002 }
5003}
5004
5005/* This is called by dlm_recoverd to process messages that were saved on
5006 the requestqueue. */
5007
5008void dlm_receive_message_saved(struct dlm_ls *ls, struct dlm_message *ms,
5009 uint32_t saved_seq)
5010{
5011 _receive_message(ls, ms, saved_seq);
5012}
5013
5014/* This is called by the midcomms layer when something is received for
5015 the lockspace. It could be either a MSG (normal message sent as part of
5016 standard locking activity) or an RCOM (recovery message sent as part of
5017 lockspace recovery). */
5018
5019void dlm_receive_buffer(union dlm_packet *p, int nodeid)
5020{
5021 struct dlm_header *hd = &p->header;
5022 struct dlm_ls *ls;
5023 int type = 0;
5024
5025 switch (hd->h_cmd) {
5026 case DLM_MSG:
5027 dlm_message_in(&p->message);
5028 type = p->message.m_type;
5029 break;
5030 case DLM_RCOM:
5031 dlm_rcom_in(&p->rcom);
5032 type = p->rcom.rc_type;
5033 break;
5034 default:
5035 log_print("invalid h_cmd %d from %u", hd->h_cmd, nodeid);
5036 return;
5037 }
5038
5039 if (hd->h_nodeid != nodeid) {
5040 log_print("invalid h_nodeid %d from %d lockspace %x",
5041 hd->h_nodeid, nodeid, hd->u.h_lockspace);
5042 return;
5043 }
5044
5045 ls = dlm_find_lockspace_global(hd->u.h_lockspace);
5046 if (!ls) {
5047 if (dlm_config.ci_log_debug) {
5048 printk_ratelimited(KERN_DEBUG "dlm: invalid lockspace "
5049 "%u from %d cmd %d type %d\n",
5050 hd->u.h_lockspace, nodeid, hd->h_cmd, type);
5051 }
5052
5053 if (hd->h_cmd == DLM_RCOM && type == DLM_RCOM_STATUS)
5054 dlm_send_ls_not_ready(nodeid, &p->rcom);
5055 return;
5056 }
5057
5058 /* this rwsem allows dlm_ls_stop() to wait for all dlm_recv threads to
5059 be inactive (in this ls) before transitioning to recovery mode */
5060
5061 down_read(&ls->ls_recv_active);
5062 if (hd->h_cmd == DLM_MSG)
5063 dlm_receive_message(ls, &p->message, nodeid);
5064 else
5065 dlm_receive_rcom(ls, &p->rcom, nodeid);
5066 up_read(&ls->ls_recv_active);
5067
5068 dlm_put_lockspace(ls);
5069}
5070
5071static void recover_convert_waiter(struct dlm_ls *ls, struct dlm_lkb *lkb,
5072 struct dlm_message *ms_stub)
5073{
5074 if (middle_conversion(lkb)) {
5075 hold_lkb(lkb);
5076 memset(ms_stub, 0, sizeof(struct dlm_message));
5077 ms_stub->m_flags = DLM_IFL_STUB_MS;
5078 ms_stub->m_type = DLM_MSG_CONVERT_REPLY;
5079 ms_stub->m_result = -EINPROGRESS;
5080 ms_stub->m_header.h_nodeid = lkb->lkb_nodeid;
5081 _receive_convert_reply(lkb, ms_stub);
5082
5083 /* Same special case as in receive_rcom_lock_args() */
5084 lkb->lkb_grmode = DLM_LOCK_IV;
5085 rsb_set_flag(lkb->lkb_resource, RSB_RECOVER_CONVERT);
5086 unhold_lkb(lkb);
5087
5088 } else if (lkb->lkb_rqmode >= lkb->lkb_grmode) {
5089 lkb->lkb_flags |= DLM_IFL_RESEND;
5090 }
5091
5092 /* lkb->lkb_rqmode < lkb->lkb_grmode shouldn't happen since down
5093 conversions are async; there's no reply from the remote master */
5094}
5095
5096/* A waiting lkb needs recovery if the master node has failed, or
5097 the master node is changing (only when no directory is used) */
5098
5099static int waiter_needs_recovery(struct dlm_ls *ls, struct dlm_lkb *lkb,
5100 int dir_nodeid)
5101{
5102 if (dlm_no_directory(ls))
5103 return 1;
5104
5105 if (dlm_is_removed(ls, lkb->lkb_wait_nodeid))
5106 return 1;
5107
5108 return 0;
5109}
5110
5111/* Recovery for locks that are waiting for replies from nodes that are now
5112 gone. We can just complete unlocks and cancels by faking a reply from the
5113 dead node. Requests and up-conversions we flag to be resent after
5114 recovery. Down-conversions can just be completed with a fake reply like
5115 unlocks. Conversions between PR and CW need special attention. */
5116
5117void dlm_recover_waiters_pre(struct dlm_ls *ls)
5118{
5119 struct dlm_lkb *lkb, *safe;
5120 struct dlm_message *ms_stub;
5121 int wait_type, stub_unlock_result, stub_cancel_result;
5122 int dir_nodeid;
5123
5124 ms_stub = kmalloc(sizeof(*ms_stub), GFP_KERNEL);
5125 if (!ms_stub)
5126 return;
5127
5128 mutex_lock(&ls->ls_waiters_mutex);
5129
5130 list_for_each_entry_safe(lkb, safe, &ls->ls_waiters, lkb_wait_reply) {
5131
5132 dir_nodeid = dlm_dir_nodeid(lkb->lkb_resource);
5133
5134 /* exclude debug messages about unlocks because there can be so
5135 many and they aren't very interesting */
5136
5137 if (lkb->lkb_wait_type != DLM_MSG_UNLOCK) {
5138 log_debug(ls, "waiter %x remote %x msg %d r_nodeid %d "
5139 "lkb_nodeid %d wait_nodeid %d dir_nodeid %d",
5140 lkb->lkb_id,
5141 lkb->lkb_remid,
5142 lkb->lkb_wait_type,
5143 lkb->lkb_resource->res_nodeid,
5144 lkb->lkb_nodeid,
5145 lkb->lkb_wait_nodeid,
5146 dir_nodeid);
5147 }
5148
5149 /* all outstanding lookups, regardless of destination will be
5150 resent after recovery is done */
5151
5152 if (lkb->lkb_wait_type == DLM_MSG_LOOKUP) {
5153 lkb->lkb_flags |= DLM_IFL_RESEND;
5154 continue;
5155 }
5156
5157 if (!waiter_needs_recovery(ls, lkb, dir_nodeid))
5158 continue;
5159
5160 wait_type = lkb->lkb_wait_type;
5161 stub_unlock_result = -DLM_EUNLOCK;
5162 stub_cancel_result = -DLM_ECANCEL;
5163
5164 /* Main reply may have been received leaving a zero wait_type,
5165 but a reply for the overlapping op may not have been
5166 received. In that case we need to fake the appropriate
5167 reply for the overlap op. */
5168
5169 if (!wait_type) {
5170 if (is_overlap_cancel(lkb)) {
5171 wait_type = DLM_MSG_CANCEL;
5172 if (lkb->lkb_grmode == DLM_LOCK_IV)
5173 stub_cancel_result = 0;
5174 }
5175 if (is_overlap_unlock(lkb)) {
5176 wait_type = DLM_MSG_UNLOCK;
5177 if (lkb->lkb_grmode == DLM_LOCK_IV)
5178 stub_unlock_result = -ENOENT;
5179 }
5180
5181 log_debug(ls, "rwpre overlap %x %x %d %d %d",
5182 lkb->lkb_id, lkb->lkb_flags, wait_type,
5183 stub_cancel_result, stub_unlock_result);
5184 }
5185
5186 switch (wait_type) {
5187
5188 case DLM_MSG_REQUEST:
5189 lkb->lkb_flags |= DLM_IFL_RESEND;
5190 break;
5191
5192 case DLM_MSG_CONVERT:
5193 recover_convert_waiter(ls, lkb, ms_stub);
5194 break;
5195
5196 case DLM_MSG_UNLOCK:
5197 hold_lkb(lkb);
5198 memset(ms_stub, 0, sizeof(struct dlm_message));
5199 ms_stub->m_flags = DLM_IFL_STUB_MS;
5200 ms_stub->m_type = DLM_MSG_UNLOCK_REPLY;
5201 ms_stub->m_result = stub_unlock_result;
5202 ms_stub->m_header.h_nodeid = lkb->lkb_nodeid;
5203 _receive_unlock_reply(lkb, ms_stub);
5204 dlm_put_lkb(lkb);
5205 break;
5206
5207 case DLM_MSG_CANCEL:
5208 hold_lkb(lkb);
5209 memset(ms_stub, 0, sizeof(struct dlm_message));
5210 ms_stub->m_flags = DLM_IFL_STUB_MS;
5211 ms_stub->m_type = DLM_MSG_CANCEL_REPLY;
5212 ms_stub->m_result = stub_cancel_result;
5213 ms_stub->m_header.h_nodeid = lkb->lkb_nodeid;
5214 _receive_cancel_reply(lkb, ms_stub);
5215 dlm_put_lkb(lkb);
5216 break;
5217
5218 default:
5219 log_error(ls, "invalid lkb wait_type %d %d",
5220 lkb->lkb_wait_type, wait_type);
5221 }
5222 schedule();
5223 }
5224 mutex_unlock(&ls->ls_waiters_mutex);
5225 kfree(ms_stub);
5226}
5227
5228static struct dlm_lkb *find_resend_waiter(struct dlm_ls *ls)
5229{
5230 struct dlm_lkb *lkb;
5231 int found = 0;
5232
5233 mutex_lock(&ls->ls_waiters_mutex);
5234 list_for_each_entry(lkb, &ls->ls_waiters, lkb_wait_reply) {
5235 if (lkb->lkb_flags & DLM_IFL_RESEND) {
5236 hold_lkb(lkb);
5237 found = 1;
5238 break;
5239 }
5240 }
5241 mutex_unlock(&ls->ls_waiters_mutex);
5242
5243 if (!found)
5244 lkb = NULL;
5245 return lkb;
5246}
5247
5248/* Deal with lookups and lkb's marked RESEND from _pre. We may now be the
5249 master or dir-node for r. Processing the lkb may result in it being placed
5250 back on waiters. */
5251
5252/* We do this after normal locking has been enabled and any saved messages
5253 (in requestqueue) have been processed. We should be confident that at
5254 this point we won't get or process a reply to any of these waiting
5255 operations. But, new ops may be coming in on the rsbs/locks here from
5256 userspace or remotely. */
5257
5258/* there may have been an overlap unlock/cancel prior to recovery or after
5259 recovery. if before, the lkb may still have a pos wait_count; if after, the
5260 overlap flag would just have been set and nothing new sent. we can be
5261 confident here than any replies to either the initial op or overlap ops
5262 prior to recovery have been received. */
5263
5264int dlm_recover_waiters_post(struct dlm_ls *ls)
5265{
5266 struct dlm_lkb *lkb;
5267 struct dlm_rsb *r;
5268 int error = 0, mstype, err, oc, ou;
5269
5270 while (1) {
5271 if (dlm_locking_stopped(ls)) {
5272 log_debug(ls, "recover_waiters_post aborted");
5273 error = -EINTR;
5274 break;
5275 }
5276
5277 lkb = find_resend_waiter(ls);
5278 if (!lkb)
5279 break;
5280
5281 r = lkb->lkb_resource;
5282 hold_rsb(r);
5283 lock_rsb(r);
5284
5285 mstype = lkb->lkb_wait_type;
5286 oc = is_overlap_cancel(lkb);
5287 ou = is_overlap_unlock(lkb);
5288 err = 0;
5289
5290 log_debug(ls, "waiter %x remote %x msg %d r_nodeid %d "
5291 "lkb_nodeid %d wait_nodeid %d dir_nodeid %d "
5292 "overlap %d %d", lkb->lkb_id, lkb->lkb_remid, mstype,
5293 r->res_nodeid, lkb->lkb_nodeid, lkb->lkb_wait_nodeid,
5294 dlm_dir_nodeid(r), oc, ou);
5295
5296 /* At this point we assume that we won't get a reply to any
5297 previous op or overlap op on this lock. First, do a big
5298 remove_from_waiters() for all previous ops. */
5299
5300 lkb->lkb_flags &= ~DLM_IFL_RESEND;
5301 lkb->lkb_flags &= ~DLM_IFL_OVERLAP_UNLOCK;
5302 lkb->lkb_flags &= ~DLM_IFL_OVERLAP_CANCEL;
5303 lkb->lkb_wait_type = 0;
5304 lkb->lkb_wait_count = 0;
5305 mutex_lock(&ls->ls_waiters_mutex);
5306 list_del_init(&lkb->lkb_wait_reply);
5307 mutex_unlock(&ls->ls_waiters_mutex);
5308 unhold_lkb(lkb); /* for waiters list */
5309
5310 if (oc || ou) {
5311 /* do an unlock or cancel instead of resending */
5312 switch (mstype) {
5313 case DLM_MSG_LOOKUP:
5314 case DLM_MSG_REQUEST:
5315 queue_cast(r, lkb, ou ? -DLM_EUNLOCK :
5316 -DLM_ECANCEL);
5317 unhold_lkb(lkb); /* undoes create_lkb() */
5318 break;
5319 case DLM_MSG_CONVERT:
5320 if (oc) {
5321 queue_cast(r, lkb, -DLM_ECANCEL);
5322 } else {
5323 lkb->lkb_exflags |= DLM_LKF_FORCEUNLOCK;
5324 _unlock_lock(r, lkb);
5325 }
5326 break;
5327 default:
5328 err = 1;
5329 }
5330 } else {
5331 switch (mstype) {
5332 case DLM_MSG_LOOKUP:
5333 case DLM_MSG_REQUEST:
5334 _request_lock(r, lkb);
5335 if (is_master(r))
5336 confirm_master(r, 0);
5337 break;
5338 case DLM_MSG_CONVERT:
5339 _convert_lock(r, lkb);
5340 break;
5341 default:
5342 err = 1;
5343 }
5344 }
5345
5346 if (err) {
5347 log_error(ls, "waiter %x msg %d r_nodeid %d "
5348 "dir_nodeid %d overlap %d %d",
5349 lkb->lkb_id, mstype, r->res_nodeid,
5350 dlm_dir_nodeid(r), oc, ou);
5351 }
5352 unlock_rsb(r);
5353 put_rsb(r);
5354 dlm_put_lkb(lkb);
5355 }
5356
5357 return error;
5358}
5359
5360static void purge_mstcpy_list(struct dlm_ls *ls, struct dlm_rsb *r,
5361 struct list_head *list)
5362{
5363 struct dlm_lkb *lkb, *safe;
5364
5365 list_for_each_entry_safe(lkb, safe, list, lkb_statequeue) {
5366 if (!is_master_copy(lkb))
5367 continue;
5368
5369 /* don't purge lkbs we've added in recover_master_copy for
5370 the current recovery seq */
5371
5372 if (lkb->lkb_recover_seq == ls->ls_recover_seq)
5373 continue;
5374
5375 del_lkb(r, lkb);
5376
5377 /* this put should free the lkb */
5378 if (!dlm_put_lkb(lkb))
5379 log_error(ls, "purged mstcpy lkb not released");
5380 }
5381}
5382
5383void dlm_purge_mstcpy_locks(struct dlm_rsb *r)
5384{
5385 struct dlm_ls *ls = r->res_ls;
5386
5387 purge_mstcpy_list(ls, r, &r->res_grantqueue);
5388 purge_mstcpy_list(ls, r, &r->res_convertqueue);
5389 purge_mstcpy_list(ls, r, &r->res_waitqueue);
5390}
5391
5392static void purge_dead_list(struct dlm_ls *ls, struct dlm_rsb *r,
5393 struct list_head *list,
5394 int nodeid_gone, unsigned int *count)
5395{
5396 struct dlm_lkb *lkb, *safe;
5397
5398 list_for_each_entry_safe(lkb, safe, list, lkb_statequeue) {
5399 if (!is_master_copy(lkb))
5400 continue;
5401
5402 if ((lkb->lkb_nodeid == nodeid_gone) ||
5403 dlm_is_removed(ls, lkb->lkb_nodeid)) {
5404
5405 /* tell recover_lvb to invalidate the lvb
5406 because a node holding EX/PW failed */
5407 if ((lkb->lkb_exflags & DLM_LKF_VALBLK) &&
5408 (lkb->lkb_grmode >= DLM_LOCK_PW)) {
5409 rsb_set_flag(r, RSB_RECOVER_LVB_INVAL);
5410 }
5411
5412 del_lkb(r, lkb);
5413
5414 /* this put should free the lkb */
5415 if (!dlm_put_lkb(lkb))
5416 log_error(ls, "purged dead lkb not released");
5417
5418 rsb_set_flag(r, RSB_RECOVER_GRANT);
5419
5420 (*count)++;
5421 }
5422 }
5423}
5424
5425/* Get rid of locks held by nodes that are gone. */
5426
5427void dlm_recover_purge(struct dlm_ls *ls)
5428{
5429 struct dlm_rsb *r;
5430 struct dlm_member *memb;
5431 int nodes_count = 0;
5432 int nodeid_gone = 0;
5433 unsigned int lkb_count = 0;
5434
5435 /* cache one removed nodeid to optimize the common
5436 case of a single node removed */
5437
5438 list_for_each_entry(memb, &ls->ls_nodes_gone, list) {
5439 nodes_count++;
5440 nodeid_gone = memb->nodeid;
5441 }
5442
5443 if (!nodes_count)
5444 return;
5445
5446 down_write(&ls->ls_root_sem);
5447 list_for_each_entry(r, &ls->ls_root_list, res_root_list) {
5448 hold_rsb(r);
5449 lock_rsb(r);
5450 if (is_master(r)) {
5451 purge_dead_list(ls, r, &r->res_grantqueue,
5452 nodeid_gone, &lkb_count);
5453 purge_dead_list(ls, r, &r->res_convertqueue,
5454 nodeid_gone, &lkb_count);
5455 purge_dead_list(ls, r, &r->res_waitqueue,
5456 nodeid_gone, &lkb_count);
5457 }
5458 unlock_rsb(r);
5459 unhold_rsb(r);
5460 cond_resched();
5461 }
5462 up_write(&ls->ls_root_sem);
5463
5464 if (lkb_count)
5465 log_rinfo(ls, "dlm_recover_purge %u locks for %u nodes",
5466 lkb_count, nodes_count);
5467}
5468
5469static struct dlm_rsb *find_grant_rsb(struct dlm_ls *ls, int bucket)
5470{
5471 struct rb_node *n;
5472 struct dlm_rsb *r;
5473
5474 spin_lock(&ls->ls_rsbtbl[bucket].lock);
5475 for (n = rb_first(&ls->ls_rsbtbl[bucket].keep); n; n = rb_next(n)) {
5476 r = rb_entry(n, struct dlm_rsb, res_hashnode);
5477
5478 if (!rsb_flag(r, RSB_RECOVER_GRANT))
5479 continue;
5480 if (!is_master(r)) {
5481 rsb_clear_flag(r, RSB_RECOVER_GRANT);
5482 continue;
5483 }
5484 hold_rsb(r);
5485 spin_unlock(&ls->ls_rsbtbl[bucket].lock);
5486 return r;
5487 }
5488 spin_unlock(&ls->ls_rsbtbl[bucket].lock);
5489 return NULL;
5490}
5491
5492/*
5493 * Attempt to grant locks on resources that we are the master of.
5494 * Locks may have become grantable during recovery because locks
5495 * from departed nodes have been purged (or not rebuilt), allowing
5496 * previously blocked locks to now be granted. The subset of rsb's
5497 * we are interested in are those with lkb's on either the convert or
5498 * waiting queues.
5499 *
5500 * Simplest would be to go through each master rsb and check for non-empty
5501 * convert or waiting queues, and attempt to grant on those rsbs.
5502 * Checking the queues requires lock_rsb, though, for which we'd need
5503 * to release the rsbtbl lock. This would make iterating through all
5504 * rsb's very inefficient. So, we rely on earlier recovery routines
5505 * to set RECOVER_GRANT on any rsb's that we should attempt to grant
5506 * locks for.
5507 */
5508
5509void dlm_recover_grant(struct dlm_ls *ls)
5510{
5511 struct dlm_rsb *r;
5512 int bucket = 0;
5513 unsigned int count = 0;
5514 unsigned int rsb_count = 0;
5515 unsigned int lkb_count = 0;
5516
5517 while (1) {
5518 r = find_grant_rsb(ls, bucket);
5519 if (!r) {
5520 if (bucket == ls->ls_rsbtbl_size - 1)
5521 break;
5522 bucket++;
5523 continue;
5524 }
5525 rsb_count++;
5526 count = 0;
5527 lock_rsb(r);
5528 /* the RECOVER_GRANT flag is checked in the grant path */
5529 grant_pending_locks(r, &count);
5530 rsb_clear_flag(r, RSB_RECOVER_GRANT);
5531 lkb_count += count;
5532 confirm_master(r, 0);
5533 unlock_rsb(r);
5534 put_rsb(r);
5535 cond_resched();
5536 }
5537
5538 if (lkb_count)
5539 log_rinfo(ls, "dlm_recover_grant %u locks on %u resources",
5540 lkb_count, rsb_count);
5541}
5542
5543static struct dlm_lkb *search_remid_list(struct list_head *head, int nodeid,
5544 uint32_t remid)
5545{
5546 struct dlm_lkb *lkb;
5547
5548 list_for_each_entry(lkb, head, lkb_statequeue) {
5549 if (lkb->lkb_nodeid == nodeid && lkb->lkb_remid == remid)
5550 return lkb;
5551 }
5552 return NULL;
5553}
5554
5555static struct dlm_lkb *search_remid(struct dlm_rsb *r, int nodeid,
5556 uint32_t remid)
5557{
5558 struct dlm_lkb *lkb;
5559
5560 lkb = search_remid_list(&r->res_grantqueue, nodeid, remid);
5561 if (lkb)
5562 return lkb;
5563 lkb = search_remid_list(&r->res_convertqueue, nodeid, remid);
5564 if (lkb)
5565 return lkb;
5566 lkb = search_remid_list(&r->res_waitqueue, nodeid, remid);
5567 if (lkb)
5568 return lkb;
5569 return NULL;
5570}
5571
5572/* needs at least dlm_rcom + rcom_lock */
5573static int receive_rcom_lock_args(struct dlm_ls *ls, struct dlm_lkb *lkb,
5574 struct dlm_rsb *r, struct dlm_rcom *rc)
5575{
5576 struct rcom_lock *rl = (struct rcom_lock *) rc->rc_buf;
5577
5578 lkb->lkb_nodeid = rc->rc_header.h_nodeid;
5579 lkb->lkb_ownpid = le32_to_cpu(rl->rl_ownpid);
5580 lkb->lkb_remid = le32_to_cpu(rl->rl_lkid);
5581 lkb->lkb_exflags = le32_to_cpu(rl->rl_exflags);
5582 lkb->lkb_flags = le32_to_cpu(rl->rl_flags) & 0x0000FFFF;
5583 lkb->lkb_flags |= DLM_IFL_MSTCPY;
5584 lkb->lkb_lvbseq = le32_to_cpu(rl->rl_lvbseq);
5585 lkb->lkb_rqmode = rl->rl_rqmode;
5586 lkb->lkb_grmode = rl->rl_grmode;
5587 /* don't set lkb_status because add_lkb wants to itself */
5588
5589 lkb->lkb_bastfn = (rl->rl_asts & DLM_CB_BAST) ? &fake_bastfn : NULL;
5590 lkb->lkb_astfn = (rl->rl_asts & DLM_CB_CAST) ? &fake_astfn : NULL;
5591
5592 if (lkb->lkb_exflags & DLM_LKF_VALBLK) {
5593 int lvblen = rc->rc_header.h_length - sizeof(struct dlm_rcom) -
5594 sizeof(struct rcom_lock);
5595 if (lvblen > ls->ls_lvblen)
5596 return -EINVAL;
5597 lkb->lkb_lvbptr = dlm_allocate_lvb(ls);
5598 if (!lkb->lkb_lvbptr)
5599 return -ENOMEM;
5600 memcpy(lkb->lkb_lvbptr, rl->rl_lvb, lvblen);
5601 }
5602
5603 /* Conversions between PR and CW (middle modes) need special handling.
5604 The real granted mode of these converting locks cannot be determined
5605 until all locks have been rebuilt on the rsb (recover_conversion) */
5606
5607 if (rl->rl_wait_type == cpu_to_le16(DLM_MSG_CONVERT) &&
5608 middle_conversion(lkb)) {
5609 rl->rl_status = DLM_LKSTS_CONVERT;
5610 lkb->lkb_grmode = DLM_LOCK_IV;
5611 rsb_set_flag(r, RSB_RECOVER_CONVERT);
5612 }
5613
5614 return 0;
5615}
5616
5617/* This lkb may have been recovered in a previous aborted recovery so we need
5618 to check if the rsb already has an lkb with the given remote nodeid/lkid.
5619 If so we just send back a standard reply. If not, we create a new lkb with
5620 the given values and send back our lkid. We send back our lkid by sending
5621 back the rcom_lock struct we got but with the remid field filled in. */
5622
5623/* needs at least dlm_rcom + rcom_lock */
5624int dlm_recover_master_copy(struct dlm_ls *ls, struct dlm_rcom *rc)
5625{
5626 struct rcom_lock *rl = (struct rcom_lock *) rc->rc_buf;
5627 struct dlm_rsb *r;
5628 struct dlm_lkb *lkb;
5629 uint32_t remid = 0;
5630 int from_nodeid = rc->rc_header.h_nodeid;
5631 int error;
5632
5633 if (rl->rl_parent_lkid) {
5634 error = -EOPNOTSUPP;
5635 goto out;
5636 }
5637
5638 remid = le32_to_cpu(rl->rl_lkid);
5639
5640 /* In general we expect the rsb returned to be R_MASTER, but we don't
5641 have to require it. Recovery of masters on one node can overlap
5642 recovery of locks on another node, so one node can send us MSTCPY
5643 locks before we've made ourselves master of this rsb. We can still
5644 add new MSTCPY locks that we receive here without any harm; when
5645 we make ourselves master, dlm_recover_masters() won't touch the
5646 MSTCPY locks we've received early. */
5647
5648 error = find_rsb(ls, rl->rl_name, le16_to_cpu(rl->rl_namelen),
5649 from_nodeid, R_RECEIVE_RECOVER, &r);
5650 if (error)
5651 goto out;
5652
5653 lock_rsb(r);
5654
5655 if (dlm_no_directory(ls) && (dlm_dir_nodeid(r) != dlm_our_nodeid())) {
5656 log_error(ls, "dlm_recover_master_copy remote %d %x not dir",
5657 from_nodeid, remid);
5658 error = -EBADR;
5659 goto out_unlock;
5660 }
5661
5662 lkb = search_remid(r, from_nodeid, remid);
5663 if (lkb) {
5664 error = -EEXIST;
5665 goto out_remid;
5666 }
5667
5668 error = create_lkb(ls, &lkb);
5669 if (error)
5670 goto out_unlock;
5671
5672 error = receive_rcom_lock_args(ls, lkb, r, rc);
5673 if (error) {
5674 __put_lkb(ls, lkb);
5675 goto out_unlock;
5676 }
5677
5678 attach_lkb(r, lkb);
5679 add_lkb(r, lkb, rl->rl_status);
5680 error = 0;
5681 ls->ls_recover_locks_in++;
5682
5683 if (!list_empty(&r->res_waitqueue) || !list_empty(&r->res_convertqueue))
5684 rsb_set_flag(r, RSB_RECOVER_GRANT);
5685
5686 out_remid:
5687 /* this is the new value returned to the lock holder for
5688 saving in its process-copy lkb */
5689 rl->rl_remid = cpu_to_le32(lkb->lkb_id);
5690
5691 lkb->lkb_recover_seq = ls->ls_recover_seq;
5692
5693 out_unlock:
5694 unlock_rsb(r);
5695 put_rsb(r);
5696 out:
5697 if (error && error != -EEXIST)
5698 log_rinfo(ls, "dlm_recover_master_copy remote %d %x error %d",
5699 from_nodeid, remid, error);
5700 rl->rl_result = cpu_to_le32(error);
5701 return error;
5702}
5703
5704/* needs at least dlm_rcom + rcom_lock */
5705int dlm_recover_process_copy(struct dlm_ls *ls, struct dlm_rcom *rc)
5706{
5707 struct rcom_lock *rl = (struct rcom_lock *) rc->rc_buf;
5708 struct dlm_rsb *r;
5709 struct dlm_lkb *lkb;
5710 uint32_t lkid, remid;
5711 int error, result;
5712
5713 lkid = le32_to_cpu(rl->rl_lkid);
5714 remid = le32_to_cpu(rl->rl_remid);
5715 result = le32_to_cpu(rl->rl_result);
5716
5717 error = find_lkb(ls, lkid, &lkb);
5718 if (error) {
5719 log_error(ls, "dlm_recover_process_copy no %x remote %d %x %d",
5720 lkid, rc->rc_header.h_nodeid, remid, result);
5721 return error;
5722 }
5723
5724 r = lkb->lkb_resource;
5725 hold_rsb(r);
5726 lock_rsb(r);
5727
5728 if (!is_process_copy(lkb)) {
5729 log_error(ls, "dlm_recover_process_copy bad %x remote %d %x %d",
5730 lkid, rc->rc_header.h_nodeid, remid, result);
5731 dlm_dump_rsb(r);
5732 unlock_rsb(r);
5733 put_rsb(r);
5734 dlm_put_lkb(lkb);
5735 return -EINVAL;
5736 }
5737
5738 switch (result) {
5739 case -EBADR:
5740 /* There's a chance the new master received our lock before
5741 dlm_recover_master_reply(), this wouldn't happen if we did
5742 a barrier between recover_masters and recover_locks. */
5743
5744 log_debug(ls, "dlm_recover_process_copy %x remote %d %x %d",
5745 lkid, rc->rc_header.h_nodeid, remid, result);
5746
5747 dlm_send_rcom_lock(r, lkb);
5748 goto out;
5749 case -EEXIST:
5750 case 0:
5751 lkb->lkb_remid = remid;
5752 break;
5753 default:
5754 log_error(ls, "dlm_recover_process_copy %x remote %d %x %d unk",
5755 lkid, rc->rc_header.h_nodeid, remid, result);
5756 }
5757
5758 /* an ack for dlm_recover_locks() which waits for replies from
5759 all the locks it sends to new masters */
5760 dlm_recovered_lock(r);
5761 out:
5762 unlock_rsb(r);
5763 put_rsb(r);
5764 dlm_put_lkb(lkb);
5765
5766 return 0;
5767}
5768
5769int dlm_user_request(struct dlm_ls *ls, struct dlm_user_args *ua,
5770 int mode, uint32_t flags, void *name, unsigned int namelen,
5771 unsigned long timeout_cs)
5772{
5773 struct dlm_lkb *lkb;
5774 struct dlm_args args;
5775 int error;
5776
5777 dlm_lock_recovery(ls);
5778
5779 error = create_lkb(ls, &lkb);
5780 if (error) {
5781 kfree(ua);
5782 goto out;
5783 }
5784
5785 if (flags & DLM_LKF_VALBLK) {
5786 ua->lksb.sb_lvbptr = kzalloc(DLM_USER_LVB_LEN, GFP_NOFS);
5787 if (!ua->lksb.sb_lvbptr) {
5788 kfree(ua);
5789 __put_lkb(ls, lkb);
5790 error = -ENOMEM;
5791 goto out;
5792 }
5793 }
5794 error = set_lock_args(mode, &ua->lksb, flags, namelen, timeout_cs,
5795 fake_astfn, ua, fake_bastfn, &args);
5796 if (error) {
5797 kfree(ua->lksb.sb_lvbptr);
5798 ua->lksb.sb_lvbptr = NULL;
5799 kfree(ua);
5800 __put_lkb(ls, lkb);
5801 goto out;
5802 }
5803
5804 /* After ua is attached to lkb it will be freed by dlm_free_lkb().
5805 When DLM_IFL_USER is set, the dlm knows that this is a userspace
5806 lock and that lkb_astparam is the dlm_user_args structure. */
5807 lkb->lkb_flags |= DLM_IFL_USER;
5808 error = request_lock(ls, lkb, name, namelen, &args);
5809
5810 switch (error) {
5811 case 0:
5812 break;
5813 case -EINPROGRESS:
5814 error = 0;
5815 break;
5816 case -EAGAIN:
5817 error = 0;
5818 fallthrough;
5819 default:
5820 __put_lkb(ls, lkb);
5821 goto out;
5822 }
5823
5824 /* add this new lkb to the per-process list of locks */
5825 spin_lock(&ua->proc->locks_spin);
5826 hold_lkb(lkb);
5827 list_add_tail(&lkb->lkb_ownqueue, &ua->proc->locks);
5828 spin_unlock(&ua->proc->locks_spin);
5829 out:
5830 dlm_unlock_recovery(ls);
5831 return error;
5832}
5833
5834int dlm_user_convert(struct dlm_ls *ls, struct dlm_user_args *ua_tmp,
5835 int mode, uint32_t flags, uint32_t lkid, char *lvb_in,
5836 unsigned long timeout_cs)
5837{
5838 struct dlm_lkb *lkb;
5839 struct dlm_args args;
5840 struct dlm_user_args *ua;
5841 int error;
5842
5843 dlm_lock_recovery(ls);
5844
5845 error = find_lkb(ls, lkid, &lkb);
5846 if (error)
5847 goto out;
5848
5849 /* user can change the params on its lock when it converts it, or
5850 add an lvb that didn't exist before */
5851
5852 ua = lkb->lkb_ua;
5853
5854 if (flags & DLM_LKF_VALBLK && !ua->lksb.sb_lvbptr) {
5855 ua->lksb.sb_lvbptr = kzalloc(DLM_USER_LVB_LEN, GFP_NOFS);
5856 if (!ua->lksb.sb_lvbptr) {
5857 error = -ENOMEM;
5858 goto out_put;
5859 }
5860 }
5861 if (lvb_in && ua->lksb.sb_lvbptr)
5862 memcpy(ua->lksb.sb_lvbptr, lvb_in, DLM_USER_LVB_LEN);
5863
5864 ua->xid = ua_tmp->xid;
5865 ua->castparam = ua_tmp->castparam;
5866 ua->castaddr = ua_tmp->castaddr;
5867 ua->bastparam = ua_tmp->bastparam;
5868 ua->bastaddr = ua_tmp->bastaddr;
5869 ua->user_lksb = ua_tmp->user_lksb;
5870
5871 error = set_lock_args(mode, &ua->lksb, flags, 0, timeout_cs,
5872 fake_astfn, ua, fake_bastfn, &args);
5873 if (error)
5874 goto out_put;
5875
5876 error = convert_lock(ls, lkb, &args);
5877
5878 if (error == -EINPROGRESS || error == -EAGAIN || error == -EDEADLK)
5879 error = 0;
5880 out_put:
5881 dlm_put_lkb(lkb);
5882 out:
5883 dlm_unlock_recovery(ls);
5884 kfree(ua_tmp);
5885 return error;
5886}
5887
5888/*
5889 * The caller asks for an orphan lock on a given resource with a given mode.
5890 * If a matching lock exists, it's moved to the owner's list of locks and
5891 * the lkid is returned.
5892 */
5893
5894int dlm_user_adopt_orphan(struct dlm_ls *ls, struct dlm_user_args *ua_tmp,
5895 int mode, uint32_t flags, void *name, unsigned int namelen,
5896 unsigned long timeout_cs, uint32_t *lkid)
5897{
5898 struct dlm_lkb *lkb;
5899 struct dlm_user_args *ua;
5900 int found_other_mode = 0;
5901 int found = 0;
5902 int rv = 0;
5903
5904 mutex_lock(&ls->ls_orphans_mutex);
5905 list_for_each_entry(lkb, &ls->ls_orphans, lkb_ownqueue) {
5906 if (lkb->lkb_resource->res_length != namelen)
5907 continue;
5908 if (memcmp(lkb->lkb_resource->res_name, name, namelen))
5909 continue;
5910 if (lkb->lkb_grmode != mode) {
5911 found_other_mode = 1;
5912 continue;
5913 }
5914
5915 found = 1;
5916 list_del_init(&lkb->lkb_ownqueue);
5917 lkb->lkb_flags &= ~DLM_IFL_ORPHAN;
5918 *lkid = lkb->lkb_id;
5919 break;
5920 }
5921 mutex_unlock(&ls->ls_orphans_mutex);
5922
5923 if (!found && found_other_mode) {
5924 rv = -EAGAIN;
5925 goto out;
5926 }
5927
5928 if (!found) {
5929 rv = -ENOENT;
5930 goto out;
5931 }
5932
5933 lkb->lkb_exflags = flags;
5934 lkb->lkb_ownpid = (int) current->pid;
5935
5936 ua = lkb->lkb_ua;
5937
5938 ua->proc = ua_tmp->proc;
5939 ua->xid = ua_tmp->xid;
5940 ua->castparam = ua_tmp->castparam;
5941 ua->castaddr = ua_tmp->castaddr;
5942 ua->bastparam = ua_tmp->bastparam;
5943 ua->bastaddr = ua_tmp->bastaddr;
5944 ua->user_lksb = ua_tmp->user_lksb;
5945
5946 /*
5947 * The lkb reference from the ls_orphans list was not
5948 * removed above, and is now considered the reference
5949 * for the proc locks list.
5950 */
5951
5952 spin_lock(&ua->proc->locks_spin);
5953 list_add_tail(&lkb->lkb_ownqueue, &ua->proc->locks);
5954 spin_unlock(&ua->proc->locks_spin);
5955 out:
5956 kfree(ua_tmp);
5957 return rv;
5958}
5959
5960int dlm_user_unlock(struct dlm_ls *ls, struct dlm_user_args *ua_tmp,
5961 uint32_t flags, uint32_t lkid, char *lvb_in)
5962{
5963 struct dlm_lkb *lkb;
5964 struct dlm_args args;
5965 struct dlm_user_args *ua;
5966 int error;
5967
5968 dlm_lock_recovery(ls);
5969
5970 error = find_lkb(ls, lkid, &lkb);
5971 if (error)
5972 goto out;
5973
5974 ua = lkb->lkb_ua;
5975
5976 if (lvb_in && ua->lksb.sb_lvbptr)
5977 memcpy(ua->lksb.sb_lvbptr, lvb_in, DLM_USER_LVB_LEN);
5978 if (ua_tmp->castparam)
5979 ua->castparam = ua_tmp->castparam;
5980 ua->user_lksb = ua_tmp->user_lksb;
5981
5982 error = set_unlock_args(flags, ua, &args);
5983 if (error)
5984 goto out_put;
5985
5986 error = unlock_lock(ls, lkb, &args);
5987
5988 if (error == -DLM_EUNLOCK)
5989 error = 0;
5990 /* from validate_unlock_args() */
5991 if (error == -EBUSY && (flags & DLM_LKF_FORCEUNLOCK))
5992 error = 0;
5993 if (error)
5994 goto out_put;
5995
5996 spin_lock(&ua->proc->locks_spin);
5997 /* dlm_user_add_cb() may have already taken lkb off the proc list */
5998 if (!list_empty(&lkb->lkb_ownqueue))
5999 list_move(&lkb->lkb_ownqueue, &ua->proc->unlocking);
6000 spin_unlock(&ua->proc->locks_spin);
6001 out_put:
6002 dlm_put_lkb(lkb);
6003 out:
6004 dlm_unlock_recovery(ls);
6005 kfree(ua_tmp);
6006 return error;
6007}
6008
6009int dlm_user_cancel(struct dlm_ls *ls, struct dlm_user_args *ua_tmp,
6010 uint32_t flags, uint32_t lkid)
6011{
6012 struct dlm_lkb *lkb;
6013 struct dlm_args args;
6014 struct dlm_user_args *ua;
6015 int error;
6016
6017 dlm_lock_recovery(ls);
6018
6019 error = find_lkb(ls, lkid, &lkb);
6020 if (error)
6021 goto out;
6022
6023 ua = lkb->lkb_ua;
6024 if (ua_tmp->castparam)
6025 ua->castparam = ua_tmp->castparam;
6026 ua->user_lksb = ua_tmp->user_lksb;
6027
6028 error = set_unlock_args(flags, ua, &args);
6029 if (error)
6030 goto out_put;
6031
6032 error = cancel_lock(ls, lkb, &args);
6033
6034 if (error == -DLM_ECANCEL)
6035 error = 0;
6036 /* from validate_unlock_args() */
6037 if (error == -EBUSY)
6038 error = 0;
6039 out_put:
6040 dlm_put_lkb(lkb);
6041 out:
6042 dlm_unlock_recovery(ls);
6043 kfree(ua_tmp);
6044 return error;
6045}
6046
6047int dlm_user_deadlock(struct dlm_ls *ls, uint32_t flags, uint32_t lkid)
6048{
6049 struct dlm_lkb *lkb;
6050 struct dlm_args args;
6051 struct dlm_user_args *ua;
6052 struct dlm_rsb *r;
6053 int error;
6054
6055 dlm_lock_recovery(ls);
6056
6057 error = find_lkb(ls, lkid, &lkb);
6058 if (error)
6059 goto out;
6060
6061 ua = lkb->lkb_ua;
6062
6063 error = set_unlock_args(flags, ua, &args);
6064 if (error)
6065 goto out_put;
6066
6067 /* same as cancel_lock(), but set DEADLOCK_CANCEL after lock_rsb */
6068
6069 r = lkb->lkb_resource;
6070 hold_rsb(r);
6071 lock_rsb(r);
6072
6073 error = validate_unlock_args(lkb, &args);
6074 if (error)
6075 goto out_r;
6076 lkb->lkb_flags |= DLM_IFL_DEADLOCK_CANCEL;
6077
6078 error = _cancel_lock(r, lkb);
6079 out_r:
6080 unlock_rsb(r);
6081 put_rsb(r);
6082
6083 if (error == -DLM_ECANCEL)
6084 error = 0;
6085 /* from validate_unlock_args() */
6086 if (error == -EBUSY)
6087 error = 0;
6088 out_put:
6089 dlm_put_lkb(lkb);
6090 out:
6091 dlm_unlock_recovery(ls);
6092 return error;
6093}
6094
6095/* lkb's that are removed from the waiters list by revert are just left on the
6096 orphans list with the granted orphan locks, to be freed by purge */
6097
6098static int orphan_proc_lock(struct dlm_ls *ls, struct dlm_lkb *lkb)
6099{
6100 struct dlm_args args;
6101 int error;
6102
6103 hold_lkb(lkb); /* reference for the ls_orphans list */
6104 mutex_lock(&ls->ls_orphans_mutex);
6105 list_add_tail(&lkb->lkb_ownqueue, &ls->ls_orphans);
6106 mutex_unlock(&ls->ls_orphans_mutex);
6107
6108 set_unlock_args(0, lkb->lkb_ua, &args);
6109
6110 error = cancel_lock(ls, lkb, &args);
6111 if (error == -DLM_ECANCEL)
6112 error = 0;
6113 return error;
6114}
6115
6116/* The FORCEUNLOCK flag allows the unlock to go ahead even if the lkb isn't
6117 granted. Regardless of what rsb queue the lock is on, it's removed and
6118 freed. The IVVALBLK flag causes the lvb on the resource to be invalidated
6119 if our lock is PW/EX (it's ignored if our granted mode is smaller.) */
6120
6121static int unlock_proc_lock(struct dlm_ls *ls, struct dlm_lkb *lkb)
6122{
6123 struct dlm_args args;
6124 int error;
6125
6126 set_unlock_args(DLM_LKF_FORCEUNLOCK | DLM_LKF_IVVALBLK,
6127 lkb->lkb_ua, &args);
6128
6129 error = unlock_lock(ls, lkb, &args);
6130 if (error == -DLM_EUNLOCK)
6131 error = 0;
6132 return error;
6133}
6134
6135/* We have to release clear_proc_locks mutex before calling unlock_proc_lock()
6136 (which does lock_rsb) due to deadlock with receiving a message that does
6137 lock_rsb followed by dlm_user_add_cb() */
6138
6139static struct dlm_lkb *del_proc_lock(struct dlm_ls *ls,
6140 struct dlm_user_proc *proc)
6141{
6142 struct dlm_lkb *lkb = NULL;
6143
6144 mutex_lock(&ls->ls_clear_proc_locks);
6145 if (list_empty(&proc->locks))
6146 goto out;
6147
6148 lkb = list_entry(proc->locks.next, struct dlm_lkb, lkb_ownqueue);
6149 list_del_init(&lkb->lkb_ownqueue);
6150
6151 if (lkb->lkb_exflags & DLM_LKF_PERSISTENT)
6152 lkb->lkb_flags |= DLM_IFL_ORPHAN;
6153 else
6154 lkb->lkb_flags |= DLM_IFL_DEAD;
6155 out:
6156 mutex_unlock(&ls->ls_clear_proc_locks);
6157 return lkb;
6158}
6159
6160/* The ls_clear_proc_locks mutex protects against dlm_user_add_cb() which
6161 1) references lkb->ua which we free here and 2) adds lkbs to proc->asts,
6162 which we clear here. */
6163
6164/* proc CLOSING flag is set so no more device_reads should look at proc->asts
6165 list, and no more device_writes should add lkb's to proc->locks list; so we
6166 shouldn't need to take asts_spin or locks_spin here. this assumes that
6167 device reads/writes/closes are serialized -- FIXME: we may need to serialize
6168 them ourself. */
6169
6170void dlm_clear_proc_locks(struct dlm_ls *ls, struct dlm_user_proc *proc)
6171{
6172 struct dlm_lkb *lkb, *safe;
6173
6174 dlm_lock_recovery(ls);
6175
6176 while (1) {
6177 lkb = del_proc_lock(ls, proc);
6178 if (!lkb)
6179 break;
6180 del_timeout(lkb);
6181 if (lkb->lkb_exflags & DLM_LKF_PERSISTENT)
6182 orphan_proc_lock(ls, lkb);
6183 else
6184 unlock_proc_lock(ls, lkb);
6185
6186 /* this removes the reference for the proc->locks list
6187 added by dlm_user_request, it may result in the lkb
6188 being freed */
6189
6190 dlm_put_lkb(lkb);
6191 }
6192
6193 mutex_lock(&ls->ls_clear_proc_locks);
6194
6195 /* in-progress unlocks */
6196 list_for_each_entry_safe(lkb, safe, &proc->unlocking, lkb_ownqueue) {
6197 list_del_init(&lkb->lkb_ownqueue);
6198 lkb->lkb_flags |= DLM_IFL_DEAD;
6199 dlm_put_lkb(lkb);
6200 }
6201
6202 list_for_each_entry_safe(lkb, safe, &proc->asts, lkb_cb_list) {
6203 memset(&lkb->lkb_callbacks, 0,
6204 sizeof(struct dlm_callback) * DLM_CALLBACKS_SIZE);
6205 list_del_init(&lkb->lkb_cb_list);
6206 dlm_put_lkb(lkb);
6207 }
6208
6209 mutex_unlock(&ls->ls_clear_proc_locks);
6210 dlm_unlock_recovery(ls);
6211}
6212
6213static void purge_proc_locks(struct dlm_ls *ls, struct dlm_user_proc *proc)
6214{
6215 struct dlm_lkb *lkb, *safe;
6216
6217 while (1) {
6218 lkb = NULL;
6219 spin_lock(&proc->locks_spin);
6220 if (!list_empty(&proc->locks)) {
6221 lkb = list_entry(proc->locks.next, struct dlm_lkb,
6222 lkb_ownqueue);
6223 list_del_init(&lkb->lkb_ownqueue);
6224 }
6225 spin_unlock(&proc->locks_spin);
6226
6227 if (!lkb)
6228 break;
6229
6230 lkb->lkb_flags |= DLM_IFL_DEAD;
6231 unlock_proc_lock(ls, lkb);
6232 dlm_put_lkb(lkb); /* ref from proc->locks list */
6233 }
6234
6235 spin_lock(&proc->locks_spin);
6236 list_for_each_entry_safe(lkb, safe, &proc->unlocking, lkb_ownqueue) {
6237 list_del_init(&lkb->lkb_ownqueue);
6238 lkb->lkb_flags |= DLM_IFL_DEAD;
6239 dlm_put_lkb(lkb);
6240 }
6241 spin_unlock(&proc->locks_spin);
6242
6243 spin_lock(&proc->asts_spin);
6244 list_for_each_entry_safe(lkb, safe, &proc->asts, lkb_cb_list) {
6245 memset(&lkb->lkb_callbacks, 0,
6246 sizeof(struct dlm_callback) * DLM_CALLBACKS_SIZE);
6247 list_del_init(&lkb->lkb_cb_list);
6248 dlm_put_lkb(lkb);
6249 }
6250 spin_unlock(&proc->asts_spin);
6251}
6252
6253/* pid of 0 means purge all orphans */
6254
6255static void do_purge(struct dlm_ls *ls, int nodeid, int pid)
6256{
6257 struct dlm_lkb *lkb, *safe;
6258
6259 mutex_lock(&ls->ls_orphans_mutex);
6260 list_for_each_entry_safe(lkb, safe, &ls->ls_orphans, lkb_ownqueue) {
6261 if (pid && lkb->lkb_ownpid != pid)
6262 continue;
6263 unlock_proc_lock(ls, lkb);
6264 list_del_init(&lkb->lkb_ownqueue);
6265 dlm_put_lkb(lkb);
6266 }
6267 mutex_unlock(&ls->ls_orphans_mutex);
6268}
6269
6270static int send_purge(struct dlm_ls *ls, int nodeid, int pid)
6271{
6272 struct dlm_message *ms;
6273 struct dlm_mhandle *mh;
6274 int error;
6275
6276 error = _create_message(ls, sizeof(struct dlm_message), nodeid,
6277 DLM_MSG_PURGE, &ms, &mh);
6278 if (error)
6279 return error;
6280 ms->m_nodeid = nodeid;
6281 ms->m_pid = pid;
6282
6283 return send_message(mh, ms);
6284}
6285
6286int dlm_user_purge(struct dlm_ls *ls, struct dlm_user_proc *proc,
6287 int nodeid, int pid)
6288{
6289 int error = 0;
6290
6291 if (nodeid && (nodeid != dlm_our_nodeid())) {
6292 error = send_purge(ls, nodeid, pid);
6293 } else {
6294 dlm_lock_recovery(ls);
6295 if (pid == current->pid)
6296 purge_proc_locks(ls, proc);
6297 else
6298 do_purge(ls, nodeid, pid);
6299 dlm_unlock_recovery(ls);
6300 }
6301 return error;
6302}
6303
1// SPDX-License-Identifier: GPL-2.0-only
2/******************************************************************************
3*******************************************************************************
4**
5** Copyright (C) 2005-2010 Red Hat, Inc. All rights reserved.
6**
7**
8*******************************************************************************
9******************************************************************************/
10
11/* Central locking logic has four stages:
12
13 dlm_lock()
14 dlm_unlock()
15
16 request_lock(ls, lkb)
17 convert_lock(ls, lkb)
18 unlock_lock(ls, lkb)
19 cancel_lock(ls, lkb)
20
21 _request_lock(r, lkb)
22 _convert_lock(r, lkb)
23 _unlock_lock(r, lkb)
24 _cancel_lock(r, lkb)
25
26 do_request(r, lkb)
27 do_convert(r, lkb)
28 do_unlock(r, lkb)
29 do_cancel(r, lkb)
30
31 Stage 1 (lock, unlock) is mainly about checking input args and
32 splitting into one of the four main operations:
33
34 dlm_lock = request_lock
35 dlm_lock+CONVERT = convert_lock
36 dlm_unlock = unlock_lock
37 dlm_unlock+CANCEL = cancel_lock
38
39 Stage 2, xxxx_lock(), just finds and locks the relevant rsb which is
40 provided to the next stage.
41
42 Stage 3, _xxxx_lock(), determines if the operation is local or remote.
43 When remote, it calls send_xxxx(), when local it calls do_xxxx().
44
45 Stage 4, do_xxxx(), is the guts of the operation. It manipulates the
46 given rsb and lkb and queues callbacks.
47
48 For remote operations, send_xxxx() results in the corresponding do_xxxx()
49 function being executed on the remote node. The connecting send/receive
50 calls on local (L) and remote (R) nodes:
51
52 L: send_xxxx() -> R: receive_xxxx()
53 R: do_xxxx()
54 L: receive_xxxx_reply() <- R: send_xxxx_reply()
55*/
56#include <trace/events/dlm.h>
57
58#include <linux/types.h>
59#include <linux/rbtree.h>
60#include <linux/slab.h>
61#include "dlm_internal.h"
62#include <linux/dlm_device.h>
63#include "memory.h"
64#include "midcomms.h"
65#include "requestqueue.h"
66#include "util.h"
67#include "dir.h"
68#include "member.h"
69#include "lockspace.h"
70#include "ast.h"
71#include "lock.h"
72#include "rcom.h"
73#include "recover.h"
74#include "lvb_table.h"
75#include "user.h"
76#include "config.h"
77
78static int send_request(struct dlm_rsb *r, struct dlm_lkb *lkb);
79static int send_convert(struct dlm_rsb *r, struct dlm_lkb *lkb);
80static int send_unlock(struct dlm_rsb *r, struct dlm_lkb *lkb);
81static int send_cancel(struct dlm_rsb *r, struct dlm_lkb *lkb);
82static int send_grant(struct dlm_rsb *r, struct dlm_lkb *lkb);
83static int send_bast(struct dlm_rsb *r, struct dlm_lkb *lkb, int mode);
84static int send_lookup(struct dlm_rsb *r, struct dlm_lkb *lkb);
85static int send_remove(struct dlm_rsb *r);
86static int _request_lock(struct dlm_rsb *r, struct dlm_lkb *lkb);
87static int _cancel_lock(struct dlm_rsb *r, struct dlm_lkb *lkb);
88static void __receive_convert_reply(struct dlm_rsb *r, struct dlm_lkb *lkb,
89 const struct dlm_message *ms, bool local);
90static int receive_extralen(const struct dlm_message *ms);
91static void do_purge(struct dlm_ls *ls, int nodeid, int pid);
92static void toss_rsb(struct kref *kref);
93
94/*
95 * Lock compatibilty matrix - thanks Steve
96 * UN = Unlocked state. Not really a state, used as a flag
97 * PD = Padding. Used to make the matrix a nice power of two in size
98 * Other states are the same as the VMS DLM.
99 * Usage: matrix[grmode+1][rqmode+1] (although m[rq+1][gr+1] is the same)
100 */
101
102static const int __dlm_compat_matrix[8][8] = {
103 /* UN NL CR CW PR PW EX PD */
104 {1, 1, 1, 1, 1, 1, 1, 0}, /* UN */
105 {1, 1, 1, 1, 1, 1, 1, 0}, /* NL */
106 {1, 1, 1, 1, 1, 1, 0, 0}, /* CR */
107 {1, 1, 1, 1, 0, 0, 0, 0}, /* CW */
108 {1, 1, 1, 0, 1, 0, 0, 0}, /* PR */
109 {1, 1, 1, 0, 0, 0, 0, 0}, /* PW */
110 {1, 1, 0, 0, 0, 0, 0, 0}, /* EX */
111 {0, 0, 0, 0, 0, 0, 0, 0} /* PD */
112};
113
114/*
115 * This defines the direction of transfer of LVB data.
116 * Granted mode is the row; requested mode is the column.
117 * Usage: matrix[grmode+1][rqmode+1]
118 * 1 = LVB is returned to the caller
119 * 0 = LVB is written to the resource
120 * -1 = nothing happens to the LVB
121 */
122
123const int dlm_lvb_operations[8][8] = {
124 /* UN NL CR CW PR PW EX PD*/
125 { -1, 1, 1, 1, 1, 1, 1, -1 }, /* UN */
126 { -1, 1, 1, 1, 1, 1, 1, 0 }, /* NL */
127 { -1, -1, 1, 1, 1, 1, 1, 0 }, /* CR */
128 { -1, -1, -1, 1, 1, 1, 1, 0 }, /* CW */
129 { -1, -1, -1, -1, 1, 1, 1, 0 }, /* PR */
130 { -1, 0, 0, 0, 0, 0, 1, 0 }, /* PW */
131 { -1, 0, 0, 0, 0, 0, 0, 0 }, /* EX */
132 { -1, 0, 0, 0, 0, 0, 0, 0 } /* PD */
133};
134
135#define modes_compat(gr, rq) \
136 __dlm_compat_matrix[(gr)->lkb_grmode + 1][(rq)->lkb_rqmode + 1]
137
138int dlm_modes_compat(int mode1, int mode2)
139{
140 return __dlm_compat_matrix[mode1 + 1][mode2 + 1];
141}
142
143/*
144 * Compatibility matrix for conversions with QUECVT set.
145 * Granted mode is the row; requested mode is the column.
146 * Usage: matrix[grmode+1][rqmode+1]
147 */
148
149static const int __quecvt_compat_matrix[8][8] = {
150 /* UN NL CR CW PR PW EX PD */
151 {0, 0, 0, 0, 0, 0, 0, 0}, /* UN */
152 {0, 0, 1, 1, 1, 1, 1, 0}, /* NL */
153 {0, 0, 0, 1, 1, 1, 1, 0}, /* CR */
154 {0, 0, 0, 0, 1, 1, 1, 0}, /* CW */
155 {0, 0, 0, 1, 0, 1, 1, 0}, /* PR */
156 {0, 0, 0, 0, 0, 0, 1, 0}, /* PW */
157 {0, 0, 0, 0, 0, 0, 0, 0}, /* EX */
158 {0, 0, 0, 0, 0, 0, 0, 0} /* PD */
159};
160
161void dlm_print_lkb(struct dlm_lkb *lkb)
162{
163 printk(KERN_ERR "lkb: nodeid %d id %x remid %x exflags %x flags %x "
164 "sts %d rq %d gr %d wait_type %d wait_nodeid %d seq %llu\n",
165 lkb->lkb_nodeid, lkb->lkb_id, lkb->lkb_remid, lkb->lkb_exflags,
166 dlm_iflags_val(lkb), lkb->lkb_status, lkb->lkb_rqmode,
167 lkb->lkb_grmode, lkb->lkb_wait_type, lkb->lkb_wait_nodeid,
168 (unsigned long long)lkb->lkb_recover_seq);
169}
170
171static void dlm_print_rsb(struct dlm_rsb *r)
172{
173 printk(KERN_ERR "rsb: nodeid %d master %d dir %d flags %lx first %x "
174 "rlc %d name %s\n",
175 r->res_nodeid, r->res_master_nodeid, r->res_dir_nodeid,
176 r->res_flags, r->res_first_lkid, r->res_recover_locks_count,
177 r->res_name);
178}
179
180void dlm_dump_rsb(struct dlm_rsb *r)
181{
182 struct dlm_lkb *lkb;
183
184 dlm_print_rsb(r);
185
186 printk(KERN_ERR "rsb: root_list empty %d recover_list empty %d\n",
187 list_empty(&r->res_root_list), list_empty(&r->res_recover_list));
188 printk(KERN_ERR "rsb lookup list\n");
189 list_for_each_entry(lkb, &r->res_lookup, lkb_rsb_lookup)
190 dlm_print_lkb(lkb);
191 printk(KERN_ERR "rsb grant queue:\n");
192 list_for_each_entry(lkb, &r->res_grantqueue, lkb_statequeue)
193 dlm_print_lkb(lkb);
194 printk(KERN_ERR "rsb convert queue:\n");
195 list_for_each_entry(lkb, &r->res_convertqueue, lkb_statequeue)
196 dlm_print_lkb(lkb);
197 printk(KERN_ERR "rsb wait queue:\n");
198 list_for_each_entry(lkb, &r->res_waitqueue, lkb_statequeue)
199 dlm_print_lkb(lkb);
200}
201
202/* Threads cannot use the lockspace while it's being recovered */
203
204static inline void dlm_lock_recovery(struct dlm_ls *ls)
205{
206 down_read(&ls->ls_in_recovery);
207}
208
209void dlm_unlock_recovery(struct dlm_ls *ls)
210{
211 up_read(&ls->ls_in_recovery);
212}
213
214int dlm_lock_recovery_try(struct dlm_ls *ls)
215{
216 return down_read_trylock(&ls->ls_in_recovery);
217}
218
219static inline int can_be_queued(struct dlm_lkb *lkb)
220{
221 return !(lkb->lkb_exflags & DLM_LKF_NOQUEUE);
222}
223
224static inline int force_blocking_asts(struct dlm_lkb *lkb)
225{
226 return (lkb->lkb_exflags & DLM_LKF_NOQUEUEBAST);
227}
228
229static inline int is_demoted(struct dlm_lkb *lkb)
230{
231 return test_bit(DLM_SBF_DEMOTED_BIT, &lkb->lkb_sbflags);
232}
233
234static inline int is_altmode(struct dlm_lkb *lkb)
235{
236 return test_bit(DLM_SBF_ALTMODE_BIT, &lkb->lkb_sbflags);
237}
238
239static inline int is_granted(struct dlm_lkb *lkb)
240{
241 return (lkb->lkb_status == DLM_LKSTS_GRANTED);
242}
243
244static inline int is_remote(struct dlm_rsb *r)
245{
246 DLM_ASSERT(r->res_nodeid >= 0, dlm_print_rsb(r););
247 return !!r->res_nodeid;
248}
249
250static inline int is_process_copy(struct dlm_lkb *lkb)
251{
252 return lkb->lkb_nodeid &&
253 !test_bit(DLM_IFL_MSTCPY_BIT, &lkb->lkb_iflags);
254}
255
256static inline int is_master_copy(struct dlm_lkb *lkb)
257{
258 return test_bit(DLM_IFL_MSTCPY_BIT, &lkb->lkb_iflags);
259}
260
261static inline int middle_conversion(struct dlm_lkb *lkb)
262{
263 if ((lkb->lkb_grmode==DLM_LOCK_PR && lkb->lkb_rqmode==DLM_LOCK_CW) ||
264 (lkb->lkb_rqmode==DLM_LOCK_PR && lkb->lkb_grmode==DLM_LOCK_CW))
265 return 1;
266 return 0;
267}
268
269static inline int down_conversion(struct dlm_lkb *lkb)
270{
271 return (!middle_conversion(lkb) && lkb->lkb_rqmode < lkb->lkb_grmode);
272}
273
274static inline int is_overlap_unlock(struct dlm_lkb *lkb)
275{
276 return test_bit(DLM_IFL_OVERLAP_UNLOCK_BIT, &lkb->lkb_iflags);
277}
278
279static inline int is_overlap_cancel(struct dlm_lkb *lkb)
280{
281 return test_bit(DLM_IFL_OVERLAP_CANCEL_BIT, &lkb->lkb_iflags);
282}
283
284static inline int is_overlap(struct dlm_lkb *lkb)
285{
286 return test_bit(DLM_IFL_OVERLAP_UNLOCK_BIT, &lkb->lkb_iflags) ||
287 test_bit(DLM_IFL_OVERLAP_CANCEL_BIT, &lkb->lkb_iflags);
288}
289
290static void queue_cast(struct dlm_rsb *r, struct dlm_lkb *lkb, int rv)
291{
292 if (is_master_copy(lkb))
293 return;
294
295 DLM_ASSERT(lkb->lkb_lksb, dlm_print_lkb(lkb););
296
297 if (rv == -DLM_ECANCEL &&
298 test_and_clear_bit(DLM_IFL_DEADLOCK_CANCEL_BIT, &lkb->lkb_iflags))
299 rv = -EDEADLK;
300
301 dlm_add_cb(lkb, DLM_CB_CAST, lkb->lkb_grmode, rv, dlm_sbflags_val(lkb));
302}
303
304static inline void queue_cast_overlap(struct dlm_rsb *r, struct dlm_lkb *lkb)
305{
306 queue_cast(r, lkb,
307 is_overlap_unlock(lkb) ? -DLM_EUNLOCK : -DLM_ECANCEL);
308}
309
310static void queue_bast(struct dlm_rsb *r, struct dlm_lkb *lkb, int rqmode)
311{
312 if (is_master_copy(lkb)) {
313 send_bast(r, lkb, rqmode);
314 } else {
315 dlm_add_cb(lkb, DLM_CB_BAST, rqmode, 0, 0);
316 }
317}
318
319/*
320 * Basic operations on rsb's and lkb's
321 */
322
323/* This is only called to add a reference when the code already holds
324 a valid reference to the rsb, so there's no need for locking. */
325
326static inline void hold_rsb(struct dlm_rsb *r)
327{
328 kref_get(&r->res_ref);
329}
330
331void dlm_hold_rsb(struct dlm_rsb *r)
332{
333 hold_rsb(r);
334}
335
336/* When all references to the rsb are gone it's transferred to
337 the tossed list for later disposal. */
338
339static void put_rsb(struct dlm_rsb *r)
340{
341 struct dlm_ls *ls = r->res_ls;
342 uint32_t bucket = r->res_bucket;
343 int rv;
344
345 rv = kref_put_lock(&r->res_ref, toss_rsb,
346 &ls->ls_rsbtbl[bucket].lock);
347 if (rv)
348 spin_unlock(&ls->ls_rsbtbl[bucket].lock);
349}
350
351void dlm_put_rsb(struct dlm_rsb *r)
352{
353 put_rsb(r);
354}
355
356static int pre_rsb_struct(struct dlm_ls *ls)
357{
358 struct dlm_rsb *r1, *r2;
359 int count = 0;
360
361 spin_lock(&ls->ls_new_rsb_spin);
362 if (ls->ls_new_rsb_count > dlm_config.ci_new_rsb_count / 2) {
363 spin_unlock(&ls->ls_new_rsb_spin);
364 return 0;
365 }
366 spin_unlock(&ls->ls_new_rsb_spin);
367
368 r1 = dlm_allocate_rsb(ls);
369 r2 = dlm_allocate_rsb(ls);
370
371 spin_lock(&ls->ls_new_rsb_spin);
372 if (r1) {
373 list_add(&r1->res_hashchain, &ls->ls_new_rsb);
374 ls->ls_new_rsb_count++;
375 }
376 if (r2) {
377 list_add(&r2->res_hashchain, &ls->ls_new_rsb);
378 ls->ls_new_rsb_count++;
379 }
380 count = ls->ls_new_rsb_count;
381 spin_unlock(&ls->ls_new_rsb_spin);
382
383 if (!count)
384 return -ENOMEM;
385 return 0;
386}
387
388/* If ls->ls_new_rsb is empty, return -EAGAIN, so the caller can
389 unlock any spinlocks, go back and call pre_rsb_struct again.
390 Otherwise, take an rsb off the list and return it. */
391
392static int get_rsb_struct(struct dlm_ls *ls, const void *name, int len,
393 struct dlm_rsb **r_ret)
394{
395 struct dlm_rsb *r;
396 int count;
397
398 spin_lock(&ls->ls_new_rsb_spin);
399 if (list_empty(&ls->ls_new_rsb)) {
400 count = ls->ls_new_rsb_count;
401 spin_unlock(&ls->ls_new_rsb_spin);
402 log_debug(ls, "find_rsb retry %d %d %s",
403 count, dlm_config.ci_new_rsb_count,
404 (const char *)name);
405 return -EAGAIN;
406 }
407
408 r = list_first_entry(&ls->ls_new_rsb, struct dlm_rsb, res_hashchain);
409 list_del(&r->res_hashchain);
410 /* Convert the empty list_head to a NULL rb_node for tree usage: */
411 memset(&r->res_hashnode, 0, sizeof(struct rb_node));
412 ls->ls_new_rsb_count--;
413 spin_unlock(&ls->ls_new_rsb_spin);
414
415 r->res_ls = ls;
416 r->res_length = len;
417 memcpy(r->res_name, name, len);
418 mutex_init(&r->res_mutex);
419
420 INIT_LIST_HEAD(&r->res_lookup);
421 INIT_LIST_HEAD(&r->res_grantqueue);
422 INIT_LIST_HEAD(&r->res_convertqueue);
423 INIT_LIST_HEAD(&r->res_waitqueue);
424 INIT_LIST_HEAD(&r->res_root_list);
425 INIT_LIST_HEAD(&r->res_recover_list);
426
427 *r_ret = r;
428 return 0;
429}
430
431static int rsb_cmp(struct dlm_rsb *r, const char *name, int nlen)
432{
433 char maxname[DLM_RESNAME_MAXLEN];
434
435 memset(maxname, 0, DLM_RESNAME_MAXLEN);
436 memcpy(maxname, name, nlen);
437 return memcmp(r->res_name, maxname, DLM_RESNAME_MAXLEN);
438}
439
440int dlm_search_rsb_tree(struct rb_root *tree, const void *name, int len,
441 struct dlm_rsb **r_ret)
442{
443 struct rb_node *node = tree->rb_node;
444 struct dlm_rsb *r;
445 int rc;
446
447 while (node) {
448 r = rb_entry(node, struct dlm_rsb, res_hashnode);
449 rc = rsb_cmp(r, name, len);
450 if (rc < 0)
451 node = node->rb_left;
452 else if (rc > 0)
453 node = node->rb_right;
454 else
455 goto found;
456 }
457 *r_ret = NULL;
458 return -EBADR;
459
460 found:
461 *r_ret = r;
462 return 0;
463}
464
465static int rsb_insert(struct dlm_rsb *rsb, struct rb_root *tree)
466{
467 struct rb_node **newn = &tree->rb_node;
468 struct rb_node *parent = NULL;
469 int rc;
470
471 while (*newn) {
472 struct dlm_rsb *cur = rb_entry(*newn, struct dlm_rsb,
473 res_hashnode);
474
475 parent = *newn;
476 rc = rsb_cmp(cur, rsb->res_name, rsb->res_length);
477 if (rc < 0)
478 newn = &parent->rb_left;
479 else if (rc > 0)
480 newn = &parent->rb_right;
481 else {
482 log_print("rsb_insert match");
483 dlm_dump_rsb(rsb);
484 dlm_dump_rsb(cur);
485 return -EEXIST;
486 }
487 }
488
489 rb_link_node(&rsb->res_hashnode, parent, newn);
490 rb_insert_color(&rsb->res_hashnode, tree);
491 return 0;
492}
493
494/*
495 * Find rsb in rsbtbl and potentially create/add one
496 *
497 * Delaying the release of rsb's has a similar benefit to applications keeping
498 * NL locks on an rsb, but without the guarantee that the cached master value
499 * will still be valid when the rsb is reused. Apps aren't always smart enough
500 * to keep NL locks on an rsb that they may lock again shortly; this can lead
501 * to excessive master lookups and removals if we don't delay the release.
502 *
503 * Searching for an rsb means looking through both the normal list and toss
504 * list. When found on the toss list the rsb is moved to the normal list with
505 * ref count of 1; when found on normal list the ref count is incremented.
506 *
507 * rsb's on the keep list are being used locally and refcounted.
508 * rsb's on the toss list are not being used locally, and are not refcounted.
509 *
510 * The toss list rsb's were either
511 * - previously used locally but not any more (were on keep list, then
512 * moved to toss list when last refcount dropped)
513 * - created and put on toss list as a directory record for a lookup
514 * (we are the dir node for the res, but are not using the res right now,
515 * but some other node is)
516 *
517 * The purpose of find_rsb() is to return a refcounted rsb for local use.
518 * So, if the given rsb is on the toss list, it is moved to the keep list
519 * before being returned.
520 *
521 * toss_rsb() happens when all local usage of the rsb is done, i.e. no
522 * more refcounts exist, so the rsb is moved from the keep list to the
523 * toss list.
524 *
525 * rsb's on both keep and toss lists are used for doing a name to master
526 * lookups. rsb's that are in use locally (and being refcounted) are on
527 * the keep list, rsb's that are not in use locally (not refcounted) and
528 * only exist for name/master lookups are on the toss list.
529 *
530 * rsb's on the toss list who's dir_nodeid is not local can have stale
531 * name/master mappings. So, remote requests on such rsb's can potentially
532 * return with an error, which means the mapping is stale and needs to
533 * be updated with a new lookup. (The idea behind MASTER UNCERTAIN and
534 * first_lkid is to keep only a single outstanding request on an rsb
535 * while that rsb has a potentially stale master.)
536 */
537
538static int find_rsb_dir(struct dlm_ls *ls, const void *name, int len,
539 uint32_t hash, uint32_t b,
540 int dir_nodeid, int from_nodeid,
541 unsigned int flags, struct dlm_rsb **r_ret)
542{
543 struct dlm_rsb *r = NULL;
544 int our_nodeid = dlm_our_nodeid();
545 int from_local = 0;
546 int from_other = 0;
547 int from_dir = 0;
548 int create = 0;
549 int error;
550
551 if (flags & R_RECEIVE_REQUEST) {
552 if (from_nodeid == dir_nodeid)
553 from_dir = 1;
554 else
555 from_other = 1;
556 } else if (flags & R_REQUEST) {
557 from_local = 1;
558 }
559
560 /*
561 * flags & R_RECEIVE_RECOVER is from dlm_recover_master_copy, so
562 * from_nodeid has sent us a lock in dlm_recover_locks, believing
563 * we're the new master. Our local recovery may not have set
564 * res_master_nodeid to our_nodeid yet, so allow either. Don't
565 * create the rsb; dlm_recover_process_copy() will handle EBADR
566 * by resending.
567 *
568 * If someone sends us a request, we are the dir node, and we do
569 * not find the rsb anywhere, then recreate it. This happens if
570 * someone sends us a request after we have removed/freed an rsb
571 * from our toss list. (They sent a request instead of lookup
572 * because they are using an rsb from their toss list.)
573 */
574
575 if (from_local || from_dir ||
576 (from_other && (dir_nodeid == our_nodeid))) {
577 create = 1;
578 }
579
580 retry:
581 if (create) {
582 error = pre_rsb_struct(ls);
583 if (error < 0)
584 goto out;
585 }
586
587 spin_lock(&ls->ls_rsbtbl[b].lock);
588
589 error = dlm_search_rsb_tree(&ls->ls_rsbtbl[b].keep, name, len, &r);
590 if (error)
591 goto do_toss;
592
593 /*
594 * rsb is active, so we can't check master_nodeid without lock_rsb.
595 */
596
597 kref_get(&r->res_ref);
598 goto out_unlock;
599
600
601 do_toss:
602 error = dlm_search_rsb_tree(&ls->ls_rsbtbl[b].toss, name, len, &r);
603 if (error)
604 goto do_new;
605
606 /*
607 * rsb found inactive (master_nodeid may be out of date unless
608 * we are the dir_nodeid or were the master) No other thread
609 * is using this rsb because it's on the toss list, so we can
610 * look at or update res_master_nodeid without lock_rsb.
611 */
612
613 if ((r->res_master_nodeid != our_nodeid) && from_other) {
614 /* our rsb was not master, and another node (not the dir node)
615 has sent us a request */
616 log_debug(ls, "find_rsb toss from_other %d master %d dir %d %s",
617 from_nodeid, r->res_master_nodeid, dir_nodeid,
618 r->res_name);
619 error = -ENOTBLK;
620 goto out_unlock;
621 }
622
623 if ((r->res_master_nodeid != our_nodeid) && from_dir) {
624 /* don't think this should ever happen */
625 log_error(ls, "find_rsb toss from_dir %d master %d",
626 from_nodeid, r->res_master_nodeid);
627 dlm_print_rsb(r);
628 /* fix it and go on */
629 r->res_master_nodeid = our_nodeid;
630 r->res_nodeid = 0;
631 rsb_clear_flag(r, RSB_MASTER_UNCERTAIN);
632 r->res_first_lkid = 0;
633 }
634
635 if (from_local && (r->res_master_nodeid != our_nodeid)) {
636 /* Because we have held no locks on this rsb,
637 res_master_nodeid could have become stale. */
638 rsb_set_flag(r, RSB_MASTER_UNCERTAIN);
639 r->res_first_lkid = 0;
640 }
641
642 rb_erase(&r->res_hashnode, &ls->ls_rsbtbl[b].toss);
643 error = rsb_insert(r, &ls->ls_rsbtbl[b].keep);
644 goto out_unlock;
645
646
647 do_new:
648 /*
649 * rsb not found
650 */
651
652 if (error == -EBADR && !create)
653 goto out_unlock;
654
655 error = get_rsb_struct(ls, name, len, &r);
656 if (error == -EAGAIN) {
657 spin_unlock(&ls->ls_rsbtbl[b].lock);
658 goto retry;
659 }
660 if (error)
661 goto out_unlock;
662
663 r->res_hash = hash;
664 r->res_bucket = b;
665 r->res_dir_nodeid = dir_nodeid;
666 kref_init(&r->res_ref);
667
668 if (from_dir) {
669 /* want to see how often this happens */
670 log_debug(ls, "find_rsb new from_dir %d recreate %s",
671 from_nodeid, r->res_name);
672 r->res_master_nodeid = our_nodeid;
673 r->res_nodeid = 0;
674 goto out_add;
675 }
676
677 if (from_other && (dir_nodeid != our_nodeid)) {
678 /* should never happen */
679 log_error(ls, "find_rsb new from_other %d dir %d our %d %s",
680 from_nodeid, dir_nodeid, our_nodeid, r->res_name);
681 dlm_free_rsb(r);
682 r = NULL;
683 error = -ENOTBLK;
684 goto out_unlock;
685 }
686
687 if (from_other) {
688 log_debug(ls, "find_rsb new from_other %d dir %d %s",
689 from_nodeid, dir_nodeid, r->res_name);
690 }
691
692 if (dir_nodeid == our_nodeid) {
693 /* When we are the dir nodeid, we can set the master
694 node immediately */
695 r->res_master_nodeid = our_nodeid;
696 r->res_nodeid = 0;
697 } else {
698 /* set_master will send_lookup to dir_nodeid */
699 r->res_master_nodeid = 0;
700 r->res_nodeid = -1;
701 }
702
703 out_add:
704 error = rsb_insert(r, &ls->ls_rsbtbl[b].keep);
705 out_unlock:
706 spin_unlock(&ls->ls_rsbtbl[b].lock);
707 out:
708 *r_ret = r;
709 return error;
710}
711
712/* During recovery, other nodes can send us new MSTCPY locks (from
713 dlm_recover_locks) before we've made ourself master (in
714 dlm_recover_masters). */
715
716static int find_rsb_nodir(struct dlm_ls *ls, const void *name, int len,
717 uint32_t hash, uint32_t b,
718 int dir_nodeid, int from_nodeid,
719 unsigned int flags, struct dlm_rsb **r_ret)
720{
721 struct dlm_rsb *r = NULL;
722 int our_nodeid = dlm_our_nodeid();
723 int recover = (flags & R_RECEIVE_RECOVER);
724 int error;
725
726 retry:
727 error = pre_rsb_struct(ls);
728 if (error < 0)
729 goto out;
730
731 spin_lock(&ls->ls_rsbtbl[b].lock);
732
733 error = dlm_search_rsb_tree(&ls->ls_rsbtbl[b].keep, name, len, &r);
734 if (error)
735 goto do_toss;
736
737 /*
738 * rsb is active, so we can't check master_nodeid without lock_rsb.
739 */
740
741 kref_get(&r->res_ref);
742 goto out_unlock;
743
744
745 do_toss:
746 error = dlm_search_rsb_tree(&ls->ls_rsbtbl[b].toss, name, len, &r);
747 if (error)
748 goto do_new;
749
750 /*
751 * rsb found inactive. No other thread is using this rsb because
752 * it's on the toss list, so we can look at or update
753 * res_master_nodeid without lock_rsb.
754 */
755
756 if (!recover && (r->res_master_nodeid != our_nodeid) && from_nodeid) {
757 /* our rsb is not master, and another node has sent us a
758 request; this should never happen */
759 log_error(ls, "find_rsb toss from_nodeid %d master %d dir %d",
760 from_nodeid, r->res_master_nodeid, dir_nodeid);
761 dlm_print_rsb(r);
762 error = -ENOTBLK;
763 goto out_unlock;
764 }
765
766 if (!recover && (r->res_master_nodeid != our_nodeid) &&
767 (dir_nodeid == our_nodeid)) {
768 /* our rsb is not master, and we are dir; may as well fix it;
769 this should never happen */
770 log_error(ls, "find_rsb toss our %d master %d dir %d",
771 our_nodeid, r->res_master_nodeid, dir_nodeid);
772 dlm_print_rsb(r);
773 r->res_master_nodeid = our_nodeid;
774 r->res_nodeid = 0;
775 }
776
777 rb_erase(&r->res_hashnode, &ls->ls_rsbtbl[b].toss);
778 error = rsb_insert(r, &ls->ls_rsbtbl[b].keep);
779 goto out_unlock;
780
781
782 do_new:
783 /*
784 * rsb not found
785 */
786
787 error = get_rsb_struct(ls, name, len, &r);
788 if (error == -EAGAIN) {
789 spin_unlock(&ls->ls_rsbtbl[b].lock);
790 goto retry;
791 }
792 if (error)
793 goto out_unlock;
794
795 r->res_hash = hash;
796 r->res_bucket = b;
797 r->res_dir_nodeid = dir_nodeid;
798 r->res_master_nodeid = dir_nodeid;
799 r->res_nodeid = (dir_nodeid == our_nodeid) ? 0 : dir_nodeid;
800 kref_init(&r->res_ref);
801
802 error = rsb_insert(r, &ls->ls_rsbtbl[b].keep);
803 out_unlock:
804 spin_unlock(&ls->ls_rsbtbl[b].lock);
805 out:
806 *r_ret = r;
807 return error;
808}
809
810static int find_rsb(struct dlm_ls *ls, const void *name, int len,
811 int from_nodeid, unsigned int flags,
812 struct dlm_rsb **r_ret)
813{
814 uint32_t hash, b;
815 int dir_nodeid;
816
817 if (len > DLM_RESNAME_MAXLEN)
818 return -EINVAL;
819
820 hash = jhash(name, len, 0);
821 b = hash & (ls->ls_rsbtbl_size - 1);
822
823 dir_nodeid = dlm_hash2nodeid(ls, hash);
824
825 if (dlm_no_directory(ls))
826 return find_rsb_nodir(ls, name, len, hash, b, dir_nodeid,
827 from_nodeid, flags, r_ret);
828 else
829 return find_rsb_dir(ls, name, len, hash, b, dir_nodeid,
830 from_nodeid, flags, r_ret);
831}
832
833/* we have received a request and found that res_master_nodeid != our_nodeid,
834 so we need to return an error or make ourself the master */
835
836static int validate_master_nodeid(struct dlm_ls *ls, struct dlm_rsb *r,
837 int from_nodeid)
838{
839 if (dlm_no_directory(ls)) {
840 log_error(ls, "find_rsb keep from_nodeid %d master %d dir %d",
841 from_nodeid, r->res_master_nodeid,
842 r->res_dir_nodeid);
843 dlm_print_rsb(r);
844 return -ENOTBLK;
845 }
846
847 if (from_nodeid != r->res_dir_nodeid) {
848 /* our rsb is not master, and another node (not the dir node)
849 has sent us a request. this is much more common when our
850 master_nodeid is zero, so limit debug to non-zero. */
851
852 if (r->res_master_nodeid) {
853 log_debug(ls, "validate master from_other %d master %d "
854 "dir %d first %x %s", from_nodeid,
855 r->res_master_nodeid, r->res_dir_nodeid,
856 r->res_first_lkid, r->res_name);
857 }
858 return -ENOTBLK;
859 } else {
860 /* our rsb is not master, but the dir nodeid has sent us a
861 request; this could happen with master 0 / res_nodeid -1 */
862
863 if (r->res_master_nodeid) {
864 log_error(ls, "validate master from_dir %d master %d "
865 "first %x %s",
866 from_nodeid, r->res_master_nodeid,
867 r->res_first_lkid, r->res_name);
868 }
869
870 r->res_master_nodeid = dlm_our_nodeid();
871 r->res_nodeid = 0;
872 return 0;
873 }
874}
875
876static void __dlm_master_lookup(struct dlm_ls *ls, struct dlm_rsb *r, int our_nodeid,
877 int from_nodeid, bool toss_list, unsigned int flags,
878 int *r_nodeid, int *result)
879{
880 int fix_master = (flags & DLM_LU_RECOVER_MASTER);
881 int from_master = (flags & DLM_LU_RECOVER_DIR);
882
883 if (r->res_dir_nodeid != our_nodeid) {
884 /* should not happen, but may as well fix it and carry on */
885 log_error(ls, "%s res_dir %d our %d %s", __func__,
886 r->res_dir_nodeid, our_nodeid, r->res_name);
887 r->res_dir_nodeid = our_nodeid;
888 }
889
890 if (fix_master && dlm_is_removed(ls, r->res_master_nodeid)) {
891 /* Recovery uses this function to set a new master when
892 * the previous master failed. Setting NEW_MASTER will
893 * force dlm_recover_masters to call recover_master on this
894 * rsb even though the res_nodeid is no longer removed.
895 */
896
897 r->res_master_nodeid = from_nodeid;
898 r->res_nodeid = from_nodeid;
899 rsb_set_flag(r, RSB_NEW_MASTER);
900
901 if (toss_list) {
902 /* I don't think we should ever find it on toss list. */
903 log_error(ls, "%s fix_master on toss", __func__);
904 dlm_dump_rsb(r);
905 }
906 }
907
908 if (from_master && (r->res_master_nodeid != from_nodeid)) {
909 /* this will happen if from_nodeid became master during
910 * a previous recovery cycle, and we aborted the previous
911 * cycle before recovering this master value
912 */
913
914 log_limit(ls, "%s from_master %d master_nodeid %d res_nodeid %d first %x %s",
915 __func__, from_nodeid, r->res_master_nodeid,
916 r->res_nodeid, r->res_first_lkid, r->res_name);
917
918 if (r->res_master_nodeid == our_nodeid) {
919 log_error(ls, "from_master %d our_master", from_nodeid);
920 dlm_dump_rsb(r);
921 goto ret_assign;
922 }
923
924 r->res_master_nodeid = from_nodeid;
925 r->res_nodeid = from_nodeid;
926 rsb_set_flag(r, RSB_NEW_MASTER);
927 }
928
929 if (!r->res_master_nodeid) {
930 /* this will happen if recovery happens while we're looking
931 * up the master for this rsb
932 */
933
934 log_debug(ls, "%s master 0 to %d first %x %s", __func__,
935 from_nodeid, r->res_first_lkid, r->res_name);
936 r->res_master_nodeid = from_nodeid;
937 r->res_nodeid = from_nodeid;
938 }
939
940 if (!from_master && !fix_master &&
941 (r->res_master_nodeid == from_nodeid)) {
942 /* this can happen when the master sends remove, the dir node
943 * finds the rsb on the keep list and ignores the remove,
944 * and the former master sends a lookup
945 */
946
947 log_limit(ls, "%s from master %d flags %x first %x %s",
948 __func__, from_nodeid, flags, r->res_first_lkid,
949 r->res_name);
950 }
951
952 ret_assign:
953 *r_nodeid = r->res_master_nodeid;
954 if (result)
955 *result = DLM_LU_MATCH;
956}
957
958/*
959 * We're the dir node for this res and another node wants to know the
960 * master nodeid. During normal operation (non recovery) this is only
961 * called from receive_lookup(); master lookups when the local node is
962 * the dir node are done by find_rsb().
963 *
964 * normal operation, we are the dir node for a resource
965 * . _request_lock
966 * . set_master
967 * . send_lookup
968 * . receive_lookup
969 * . dlm_master_lookup flags 0
970 *
971 * recover directory, we are rebuilding dir for all resources
972 * . dlm_recover_directory
973 * . dlm_rcom_names
974 * remote node sends back the rsb names it is master of and we are dir of
975 * . dlm_master_lookup RECOVER_DIR (fix_master 0, from_master 1)
976 * we either create new rsb setting remote node as master, or find existing
977 * rsb and set master to be the remote node.
978 *
979 * recover masters, we are finding the new master for resources
980 * . dlm_recover_masters
981 * . recover_master
982 * . dlm_send_rcom_lookup
983 * . receive_rcom_lookup
984 * . dlm_master_lookup RECOVER_MASTER (fix_master 1, from_master 0)
985 */
986
987int dlm_master_lookup(struct dlm_ls *ls, int from_nodeid, const char *name,
988 int len, unsigned int flags, int *r_nodeid, int *result)
989{
990 struct dlm_rsb *r = NULL;
991 uint32_t hash, b;
992 int our_nodeid = dlm_our_nodeid();
993 int dir_nodeid, error;
994
995 if (len > DLM_RESNAME_MAXLEN)
996 return -EINVAL;
997
998 if (from_nodeid == our_nodeid) {
999 log_error(ls, "dlm_master_lookup from our_nodeid %d flags %x",
1000 our_nodeid, flags);
1001 return -EINVAL;
1002 }
1003
1004 hash = jhash(name, len, 0);
1005 b = hash & (ls->ls_rsbtbl_size - 1);
1006
1007 dir_nodeid = dlm_hash2nodeid(ls, hash);
1008 if (dir_nodeid != our_nodeid) {
1009 log_error(ls, "dlm_master_lookup from %d dir %d our %d h %x %d",
1010 from_nodeid, dir_nodeid, our_nodeid, hash,
1011 ls->ls_num_nodes);
1012 *r_nodeid = -1;
1013 return -EINVAL;
1014 }
1015
1016 retry:
1017 error = pre_rsb_struct(ls);
1018 if (error < 0)
1019 return error;
1020
1021 spin_lock(&ls->ls_rsbtbl[b].lock);
1022 error = dlm_search_rsb_tree(&ls->ls_rsbtbl[b].keep, name, len, &r);
1023 if (!error) {
1024 /* because the rsb is active, we need to lock_rsb before
1025 * checking/changing re_master_nodeid
1026 */
1027
1028 hold_rsb(r);
1029 spin_unlock(&ls->ls_rsbtbl[b].lock);
1030 lock_rsb(r);
1031
1032 __dlm_master_lookup(ls, r, our_nodeid, from_nodeid, false,
1033 flags, r_nodeid, result);
1034
1035 /* the rsb was active */
1036 unlock_rsb(r);
1037 put_rsb(r);
1038
1039 return 0;
1040 }
1041
1042 error = dlm_search_rsb_tree(&ls->ls_rsbtbl[b].toss, name, len, &r);
1043 if (error)
1044 goto not_found;
1045
1046 /* because the rsb is inactive (on toss list), it's not refcounted
1047 * and lock_rsb is not used, but is protected by the rsbtbl lock
1048 */
1049
1050 __dlm_master_lookup(ls, r, our_nodeid, from_nodeid, true, flags,
1051 r_nodeid, result);
1052
1053 r->res_toss_time = jiffies;
1054 /* the rsb was inactive (on toss list) */
1055 spin_unlock(&ls->ls_rsbtbl[b].lock);
1056
1057 return 0;
1058
1059 not_found:
1060 error = get_rsb_struct(ls, name, len, &r);
1061 if (error == -EAGAIN) {
1062 spin_unlock(&ls->ls_rsbtbl[b].lock);
1063 goto retry;
1064 }
1065 if (error)
1066 goto out_unlock;
1067
1068 r->res_hash = hash;
1069 r->res_bucket = b;
1070 r->res_dir_nodeid = our_nodeid;
1071 r->res_master_nodeid = from_nodeid;
1072 r->res_nodeid = from_nodeid;
1073 kref_init(&r->res_ref);
1074 r->res_toss_time = jiffies;
1075
1076 error = rsb_insert(r, &ls->ls_rsbtbl[b].toss);
1077 if (error) {
1078 /* should never happen */
1079 dlm_free_rsb(r);
1080 spin_unlock(&ls->ls_rsbtbl[b].lock);
1081 goto retry;
1082 }
1083
1084 if (result)
1085 *result = DLM_LU_ADD;
1086 *r_nodeid = from_nodeid;
1087 out_unlock:
1088 spin_unlock(&ls->ls_rsbtbl[b].lock);
1089 return error;
1090}
1091
1092static void dlm_dump_rsb_hash(struct dlm_ls *ls, uint32_t hash)
1093{
1094 struct rb_node *n;
1095 struct dlm_rsb *r;
1096 int i;
1097
1098 for (i = 0; i < ls->ls_rsbtbl_size; i++) {
1099 spin_lock(&ls->ls_rsbtbl[i].lock);
1100 for (n = rb_first(&ls->ls_rsbtbl[i].keep); n; n = rb_next(n)) {
1101 r = rb_entry(n, struct dlm_rsb, res_hashnode);
1102 if (r->res_hash == hash)
1103 dlm_dump_rsb(r);
1104 }
1105 spin_unlock(&ls->ls_rsbtbl[i].lock);
1106 }
1107}
1108
1109void dlm_dump_rsb_name(struct dlm_ls *ls, const char *name, int len)
1110{
1111 struct dlm_rsb *r = NULL;
1112 uint32_t hash, b;
1113 int error;
1114
1115 hash = jhash(name, len, 0);
1116 b = hash & (ls->ls_rsbtbl_size - 1);
1117
1118 spin_lock(&ls->ls_rsbtbl[b].lock);
1119 error = dlm_search_rsb_tree(&ls->ls_rsbtbl[b].keep, name, len, &r);
1120 if (!error)
1121 goto out_dump;
1122
1123 error = dlm_search_rsb_tree(&ls->ls_rsbtbl[b].toss, name, len, &r);
1124 if (error)
1125 goto out;
1126 out_dump:
1127 dlm_dump_rsb(r);
1128 out:
1129 spin_unlock(&ls->ls_rsbtbl[b].lock);
1130}
1131
1132static void toss_rsb(struct kref *kref)
1133{
1134 struct dlm_rsb *r = container_of(kref, struct dlm_rsb, res_ref);
1135 struct dlm_ls *ls = r->res_ls;
1136
1137 DLM_ASSERT(list_empty(&r->res_root_list), dlm_print_rsb(r););
1138 kref_init(&r->res_ref);
1139 rb_erase(&r->res_hashnode, &ls->ls_rsbtbl[r->res_bucket].keep);
1140 rsb_insert(r, &ls->ls_rsbtbl[r->res_bucket].toss);
1141 r->res_toss_time = jiffies;
1142 set_bit(DLM_RTF_SHRINK_BIT, &ls->ls_rsbtbl[r->res_bucket].flags);
1143 if (r->res_lvbptr) {
1144 dlm_free_lvb(r->res_lvbptr);
1145 r->res_lvbptr = NULL;
1146 }
1147}
1148
1149/* See comment for unhold_lkb */
1150
1151static void unhold_rsb(struct dlm_rsb *r)
1152{
1153 int rv;
1154 rv = kref_put(&r->res_ref, toss_rsb);
1155 DLM_ASSERT(!rv, dlm_dump_rsb(r););
1156}
1157
1158static void kill_rsb(struct kref *kref)
1159{
1160 struct dlm_rsb *r = container_of(kref, struct dlm_rsb, res_ref);
1161
1162 /* All work is done after the return from kref_put() so we
1163 can release the write_lock before the remove and free. */
1164
1165 DLM_ASSERT(list_empty(&r->res_lookup), dlm_dump_rsb(r););
1166 DLM_ASSERT(list_empty(&r->res_grantqueue), dlm_dump_rsb(r););
1167 DLM_ASSERT(list_empty(&r->res_convertqueue), dlm_dump_rsb(r););
1168 DLM_ASSERT(list_empty(&r->res_waitqueue), dlm_dump_rsb(r););
1169 DLM_ASSERT(list_empty(&r->res_root_list), dlm_dump_rsb(r););
1170 DLM_ASSERT(list_empty(&r->res_recover_list), dlm_dump_rsb(r););
1171}
1172
1173/* Attaching/detaching lkb's from rsb's is for rsb reference counting.
1174 The rsb must exist as long as any lkb's for it do. */
1175
1176static void attach_lkb(struct dlm_rsb *r, struct dlm_lkb *lkb)
1177{
1178 hold_rsb(r);
1179 lkb->lkb_resource = r;
1180}
1181
1182static void detach_lkb(struct dlm_lkb *lkb)
1183{
1184 if (lkb->lkb_resource) {
1185 put_rsb(lkb->lkb_resource);
1186 lkb->lkb_resource = NULL;
1187 }
1188}
1189
1190static int _create_lkb(struct dlm_ls *ls, struct dlm_lkb **lkb_ret,
1191 int start, int end)
1192{
1193 struct dlm_lkb *lkb;
1194 int rv;
1195
1196 lkb = dlm_allocate_lkb(ls);
1197 if (!lkb)
1198 return -ENOMEM;
1199
1200 lkb->lkb_last_bast_mode = -1;
1201 lkb->lkb_nodeid = -1;
1202 lkb->lkb_grmode = DLM_LOCK_IV;
1203 kref_init(&lkb->lkb_ref);
1204 INIT_LIST_HEAD(&lkb->lkb_ownqueue);
1205 INIT_LIST_HEAD(&lkb->lkb_rsb_lookup);
1206 INIT_LIST_HEAD(&lkb->lkb_cb_list);
1207 INIT_LIST_HEAD(&lkb->lkb_callbacks);
1208 spin_lock_init(&lkb->lkb_cb_lock);
1209 INIT_WORK(&lkb->lkb_cb_work, dlm_callback_work);
1210
1211 idr_preload(GFP_NOFS);
1212 spin_lock(&ls->ls_lkbidr_spin);
1213 rv = idr_alloc(&ls->ls_lkbidr, lkb, start, end, GFP_NOWAIT);
1214 if (rv >= 0)
1215 lkb->lkb_id = rv;
1216 spin_unlock(&ls->ls_lkbidr_spin);
1217 idr_preload_end();
1218
1219 if (rv < 0) {
1220 log_error(ls, "create_lkb idr error %d", rv);
1221 dlm_free_lkb(lkb);
1222 return rv;
1223 }
1224
1225 *lkb_ret = lkb;
1226 return 0;
1227}
1228
1229static int create_lkb(struct dlm_ls *ls, struct dlm_lkb **lkb_ret)
1230{
1231 return _create_lkb(ls, lkb_ret, 1, 0);
1232}
1233
1234static int find_lkb(struct dlm_ls *ls, uint32_t lkid, struct dlm_lkb **lkb_ret)
1235{
1236 struct dlm_lkb *lkb;
1237
1238 spin_lock(&ls->ls_lkbidr_spin);
1239 lkb = idr_find(&ls->ls_lkbidr, lkid);
1240 if (lkb)
1241 kref_get(&lkb->lkb_ref);
1242 spin_unlock(&ls->ls_lkbidr_spin);
1243
1244 *lkb_ret = lkb;
1245 return lkb ? 0 : -ENOENT;
1246}
1247
1248static void kill_lkb(struct kref *kref)
1249{
1250 struct dlm_lkb *lkb = container_of(kref, struct dlm_lkb, lkb_ref);
1251
1252 /* All work is done after the return from kref_put() so we
1253 can release the write_lock before the detach_lkb */
1254
1255 DLM_ASSERT(!lkb->lkb_status, dlm_print_lkb(lkb););
1256}
1257
1258/* __put_lkb() is used when an lkb may not have an rsb attached to
1259 it so we need to provide the lockspace explicitly */
1260
1261static int __put_lkb(struct dlm_ls *ls, struct dlm_lkb *lkb)
1262{
1263 uint32_t lkid = lkb->lkb_id;
1264 int rv;
1265
1266 rv = kref_put_lock(&lkb->lkb_ref, kill_lkb,
1267 &ls->ls_lkbidr_spin);
1268 if (rv) {
1269 idr_remove(&ls->ls_lkbidr, lkid);
1270 spin_unlock(&ls->ls_lkbidr_spin);
1271
1272 detach_lkb(lkb);
1273
1274 /* for local/process lkbs, lvbptr points to caller's lksb */
1275 if (lkb->lkb_lvbptr && is_master_copy(lkb))
1276 dlm_free_lvb(lkb->lkb_lvbptr);
1277 dlm_free_lkb(lkb);
1278 }
1279
1280 return rv;
1281}
1282
1283int dlm_put_lkb(struct dlm_lkb *lkb)
1284{
1285 struct dlm_ls *ls;
1286
1287 DLM_ASSERT(lkb->lkb_resource, dlm_print_lkb(lkb););
1288 DLM_ASSERT(lkb->lkb_resource->res_ls, dlm_print_lkb(lkb););
1289
1290 ls = lkb->lkb_resource->res_ls;
1291 return __put_lkb(ls, lkb);
1292}
1293
1294/* This is only called to add a reference when the code already holds
1295 a valid reference to the lkb, so there's no need for locking. */
1296
1297static inline void hold_lkb(struct dlm_lkb *lkb)
1298{
1299 kref_get(&lkb->lkb_ref);
1300}
1301
1302static void unhold_lkb_assert(struct kref *kref)
1303{
1304 struct dlm_lkb *lkb = container_of(kref, struct dlm_lkb, lkb_ref);
1305
1306 DLM_ASSERT(false, dlm_print_lkb(lkb););
1307}
1308
1309/* This is called when we need to remove a reference and are certain
1310 it's not the last ref. e.g. del_lkb is always called between a
1311 find_lkb/put_lkb and is always the inverse of a previous add_lkb.
1312 put_lkb would work fine, but would involve unnecessary locking */
1313
1314static inline void unhold_lkb(struct dlm_lkb *lkb)
1315{
1316 kref_put(&lkb->lkb_ref, unhold_lkb_assert);
1317}
1318
1319static void lkb_add_ordered(struct list_head *new, struct list_head *head,
1320 int mode)
1321{
1322 struct dlm_lkb *lkb = NULL, *iter;
1323
1324 list_for_each_entry(iter, head, lkb_statequeue)
1325 if (iter->lkb_rqmode < mode) {
1326 lkb = iter;
1327 list_add_tail(new, &iter->lkb_statequeue);
1328 break;
1329 }
1330
1331 if (!lkb)
1332 list_add_tail(new, head);
1333}
1334
1335/* add/remove lkb to rsb's grant/convert/wait queue */
1336
1337static void add_lkb(struct dlm_rsb *r, struct dlm_lkb *lkb, int status)
1338{
1339 kref_get(&lkb->lkb_ref);
1340
1341 DLM_ASSERT(!lkb->lkb_status, dlm_print_lkb(lkb););
1342
1343 lkb->lkb_timestamp = ktime_get();
1344
1345 lkb->lkb_status = status;
1346
1347 switch (status) {
1348 case DLM_LKSTS_WAITING:
1349 if (lkb->lkb_exflags & DLM_LKF_HEADQUE)
1350 list_add(&lkb->lkb_statequeue, &r->res_waitqueue);
1351 else
1352 list_add_tail(&lkb->lkb_statequeue, &r->res_waitqueue);
1353 break;
1354 case DLM_LKSTS_GRANTED:
1355 /* convention says granted locks kept in order of grmode */
1356 lkb_add_ordered(&lkb->lkb_statequeue, &r->res_grantqueue,
1357 lkb->lkb_grmode);
1358 break;
1359 case DLM_LKSTS_CONVERT:
1360 if (lkb->lkb_exflags & DLM_LKF_HEADQUE)
1361 list_add(&lkb->lkb_statequeue, &r->res_convertqueue);
1362 else
1363 list_add_tail(&lkb->lkb_statequeue,
1364 &r->res_convertqueue);
1365 break;
1366 default:
1367 DLM_ASSERT(0, dlm_print_lkb(lkb); printk("sts=%d\n", status););
1368 }
1369}
1370
1371static void del_lkb(struct dlm_rsb *r, struct dlm_lkb *lkb)
1372{
1373 lkb->lkb_status = 0;
1374 list_del(&lkb->lkb_statequeue);
1375 unhold_lkb(lkb);
1376}
1377
1378static void move_lkb(struct dlm_rsb *r, struct dlm_lkb *lkb, int sts)
1379{
1380 hold_lkb(lkb);
1381 del_lkb(r, lkb);
1382 add_lkb(r, lkb, sts);
1383 unhold_lkb(lkb);
1384}
1385
1386static int msg_reply_type(int mstype)
1387{
1388 switch (mstype) {
1389 case DLM_MSG_REQUEST:
1390 return DLM_MSG_REQUEST_REPLY;
1391 case DLM_MSG_CONVERT:
1392 return DLM_MSG_CONVERT_REPLY;
1393 case DLM_MSG_UNLOCK:
1394 return DLM_MSG_UNLOCK_REPLY;
1395 case DLM_MSG_CANCEL:
1396 return DLM_MSG_CANCEL_REPLY;
1397 case DLM_MSG_LOOKUP:
1398 return DLM_MSG_LOOKUP_REPLY;
1399 }
1400 return -1;
1401}
1402
1403/* add/remove lkb from global waiters list of lkb's waiting for
1404 a reply from a remote node */
1405
1406static int add_to_waiters(struct dlm_lkb *lkb, int mstype, int to_nodeid)
1407{
1408 struct dlm_ls *ls = lkb->lkb_resource->res_ls;
1409 int error = 0;
1410 int wc;
1411
1412 mutex_lock(&ls->ls_waiters_mutex);
1413
1414 if (is_overlap_unlock(lkb) ||
1415 (is_overlap_cancel(lkb) && (mstype == DLM_MSG_CANCEL))) {
1416 error = -EINVAL;
1417 goto out;
1418 }
1419
1420 if (lkb->lkb_wait_type || is_overlap_cancel(lkb)) {
1421 switch (mstype) {
1422 case DLM_MSG_UNLOCK:
1423 set_bit(DLM_IFL_OVERLAP_UNLOCK_BIT, &lkb->lkb_iflags);
1424 break;
1425 case DLM_MSG_CANCEL:
1426 set_bit(DLM_IFL_OVERLAP_CANCEL_BIT, &lkb->lkb_iflags);
1427 break;
1428 default:
1429 error = -EBUSY;
1430 goto out;
1431 }
1432 wc = atomic_inc_return(&lkb->lkb_wait_count);
1433 hold_lkb(lkb);
1434
1435 log_debug(ls, "addwait %x cur %d overlap %d count %d f %x",
1436 lkb->lkb_id, lkb->lkb_wait_type, mstype, wc,
1437 dlm_iflags_val(lkb));
1438 goto out;
1439 }
1440
1441 wc = atomic_fetch_inc(&lkb->lkb_wait_count);
1442 DLM_ASSERT(!wc, dlm_print_lkb(lkb); printk("wait_count %d\n", wc););
1443 lkb->lkb_wait_type = mstype;
1444 lkb->lkb_wait_nodeid = to_nodeid; /* for debugging */
1445 hold_lkb(lkb);
1446 list_add(&lkb->lkb_wait_reply, &ls->ls_waiters);
1447 out:
1448 if (error)
1449 log_error(ls, "addwait error %x %d flags %x %d %d %s",
1450 lkb->lkb_id, error, dlm_iflags_val(lkb), mstype,
1451 lkb->lkb_wait_type, lkb->lkb_resource->res_name);
1452 mutex_unlock(&ls->ls_waiters_mutex);
1453 return error;
1454}
1455
1456/* We clear the RESEND flag because we might be taking an lkb off the waiters
1457 list as part of process_requestqueue (e.g. a lookup that has an optimized
1458 request reply on the requestqueue) between dlm_recover_waiters_pre() which
1459 set RESEND and dlm_recover_waiters_post() */
1460
1461static int _remove_from_waiters(struct dlm_lkb *lkb, int mstype,
1462 const struct dlm_message *ms)
1463{
1464 struct dlm_ls *ls = lkb->lkb_resource->res_ls;
1465 int overlap_done = 0;
1466
1467 if (mstype == DLM_MSG_UNLOCK_REPLY &&
1468 test_and_clear_bit(DLM_IFL_OVERLAP_UNLOCK_BIT, &lkb->lkb_iflags)) {
1469 log_debug(ls, "remwait %x unlock_reply overlap", lkb->lkb_id);
1470 overlap_done = 1;
1471 goto out_del;
1472 }
1473
1474 if (mstype == DLM_MSG_CANCEL_REPLY &&
1475 test_and_clear_bit(DLM_IFL_OVERLAP_CANCEL_BIT, &lkb->lkb_iflags)) {
1476 log_debug(ls, "remwait %x cancel_reply overlap", lkb->lkb_id);
1477 overlap_done = 1;
1478 goto out_del;
1479 }
1480
1481 /* Cancel state was preemptively cleared by a successful convert,
1482 see next comment, nothing to do. */
1483
1484 if ((mstype == DLM_MSG_CANCEL_REPLY) &&
1485 (lkb->lkb_wait_type != DLM_MSG_CANCEL)) {
1486 log_debug(ls, "remwait %x cancel_reply wait_type %d",
1487 lkb->lkb_id, lkb->lkb_wait_type);
1488 return -1;
1489 }
1490
1491 /* Remove for the convert reply, and premptively remove for the
1492 cancel reply. A convert has been granted while there's still
1493 an outstanding cancel on it (the cancel is moot and the result
1494 in the cancel reply should be 0). We preempt the cancel reply
1495 because the app gets the convert result and then can follow up
1496 with another op, like convert. This subsequent op would see the
1497 lingering state of the cancel and fail with -EBUSY. */
1498
1499 if ((mstype == DLM_MSG_CONVERT_REPLY) &&
1500 (lkb->lkb_wait_type == DLM_MSG_CONVERT) && ms && !ms->m_result &&
1501 test_and_clear_bit(DLM_IFL_OVERLAP_CANCEL_BIT, &lkb->lkb_iflags)) {
1502 log_debug(ls, "remwait %x convert_reply zap overlap_cancel",
1503 lkb->lkb_id);
1504 lkb->lkb_wait_type = 0;
1505 atomic_dec(&lkb->lkb_wait_count);
1506 unhold_lkb(lkb);
1507 goto out_del;
1508 }
1509
1510 /* N.B. type of reply may not always correspond to type of original
1511 msg due to lookup->request optimization, verify others? */
1512
1513 if (lkb->lkb_wait_type) {
1514 lkb->lkb_wait_type = 0;
1515 goto out_del;
1516 }
1517
1518 log_error(ls, "remwait error %x remote %d %x msg %d flags %x no wait",
1519 lkb->lkb_id, ms ? le32_to_cpu(ms->m_header.h_nodeid) : 0,
1520 lkb->lkb_remid, mstype, dlm_iflags_val(lkb));
1521 return -1;
1522
1523 out_del:
1524 /* the force-unlock/cancel has completed and we haven't recvd a reply
1525 to the op that was in progress prior to the unlock/cancel; we
1526 give up on any reply to the earlier op. FIXME: not sure when/how
1527 this would happen */
1528
1529 if (overlap_done && lkb->lkb_wait_type) {
1530 log_error(ls, "remwait error %x reply %d wait_type %d overlap",
1531 lkb->lkb_id, mstype, lkb->lkb_wait_type);
1532 atomic_dec(&lkb->lkb_wait_count);
1533 unhold_lkb(lkb);
1534 lkb->lkb_wait_type = 0;
1535 }
1536
1537 DLM_ASSERT(atomic_read(&lkb->lkb_wait_count), dlm_print_lkb(lkb););
1538
1539 clear_bit(DLM_IFL_RESEND_BIT, &lkb->lkb_iflags);
1540 if (atomic_dec_and_test(&lkb->lkb_wait_count))
1541 list_del_init(&lkb->lkb_wait_reply);
1542 unhold_lkb(lkb);
1543 return 0;
1544}
1545
1546static int remove_from_waiters(struct dlm_lkb *lkb, int mstype)
1547{
1548 struct dlm_ls *ls = lkb->lkb_resource->res_ls;
1549 int error;
1550
1551 mutex_lock(&ls->ls_waiters_mutex);
1552 error = _remove_from_waiters(lkb, mstype, NULL);
1553 mutex_unlock(&ls->ls_waiters_mutex);
1554 return error;
1555}
1556
1557/* Handles situations where we might be processing a "fake" or "local" reply in
1558 which we can't try to take waiters_mutex again. */
1559
1560static int remove_from_waiters_ms(struct dlm_lkb *lkb,
1561 const struct dlm_message *ms, bool local)
1562{
1563 struct dlm_ls *ls = lkb->lkb_resource->res_ls;
1564 int error;
1565
1566 if (!local)
1567 mutex_lock(&ls->ls_waiters_mutex);
1568 error = _remove_from_waiters(lkb, le32_to_cpu(ms->m_type), ms);
1569 if (!local)
1570 mutex_unlock(&ls->ls_waiters_mutex);
1571 return error;
1572}
1573
1574static void shrink_bucket(struct dlm_ls *ls, int b)
1575{
1576 struct rb_node *n, *next;
1577 struct dlm_rsb *r;
1578 char *name;
1579 int our_nodeid = dlm_our_nodeid();
1580 int remote_count = 0;
1581 int need_shrink = 0;
1582 int i, len, rv;
1583
1584 memset(&ls->ls_remove_lens, 0, sizeof(int) * DLM_REMOVE_NAMES_MAX);
1585
1586 spin_lock(&ls->ls_rsbtbl[b].lock);
1587
1588 if (!test_bit(DLM_RTF_SHRINK_BIT, &ls->ls_rsbtbl[b].flags)) {
1589 spin_unlock(&ls->ls_rsbtbl[b].lock);
1590 return;
1591 }
1592
1593 for (n = rb_first(&ls->ls_rsbtbl[b].toss); n; n = next) {
1594 next = rb_next(n);
1595 r = rb_entry(n, struct dlm_rsb, res_hashnode);
1596
1597 /* If we're the directory record for this rsb, and
1598 we're not the master of it, then we need to wait
1599 for the master node to send us a dir remove for
1600 before removing the dir record. */
1601
1602 if (!dlm_no_directory(ls) &&
1603 (r->res_master_nodeid != our_nodeid) &&
1604 (dlm_dir_nodeid(r) == our_nodeid)) {
1605 continue;
1606 }
1607
1608 need_shrink = 1;
1609
1610 if (!time_after_eq(jiffies, r->res_toss_time +
1611 dlm_config.ci_toss_secs * HZ)) {
1612 continue;
1613 }
1614
1615 if (!dlm_no_directory(ls) &&
1616 (r->res_master_nodeid == our_nodeid) &&
1617 (dlm_dir_nodeid(r) != our_nodeid)) {
1618
1619 /* We're the master of this rsb but we're not
1620 the directory record, so we need to tell the
1621 dir node to remove the dir record. */
1622
1623 ls->ls_remove_lens[remote_count] = r->res_length;
1624 memcpy(ls->ls_remove_names[remote_count], r->res_name,
1625 DLM_RESNAME_MAXLEN);
1626 remote_count++;
1627
1628 if (remote_count >= DLM_REMOVE_NAMES_MAX)
1629 break;
1630 continue;
1631 }
1632
1633 if (!kref_put(&r->res_ref, kill_rsb)) {
1634 log_error(ls, "tossed rsb in use %s", r->res_name);
1635 continue;
1636 }
1637
1638 rb_erase(&r->res_hashnode, &ls->ls_rsbtbl[b].toss);
1639 dlm_free_rsb(r);
1640 }
1641
1642 if (need_shrink)
1643 set_bit(DLM_RTF_SHRINK_BIT, &ls->ls_rsbtbl[b].flags);
1644 else
1645 clear_bit(DLM_RTF_SHRINK_BIT, &ls->ls_rsbtbl[b].flags);
1646 spin_unlock(&ls->ls_rsbtbl[b].lock);
1647
1648 /*
1649 * While searching for rsb's to free, we found some that require
1650 * remote removal. We leave them in place and find them again here
1651 * so there is a very small gap between removing them from the toss
1652 * list and sending the removal. Keeping this gap small is
1653 * important to keep us (the master node) from being out of sync
1654 * with the remote dir node for very long.
1655 */
1656
1657 for (i = 0; i < remote_count; i++) {
1658 name = ls->ls_remove_names[i];
1659 len = ls->ls_remove_lens[i];
1660
1661 spin_lock(&ls->ls_rsbtbl[b].lock);
1662 rv = dlm_search_rsb_tree(&ls->ls_rsbtbl[b].toss, name, len, &r);
1663 if (rv) {
1664 spin_unlock(&ls->ls_rsbtbl[b].lock);
1665 log_debug(ls, "remove_name not toss %s", name);
1666 continue;
1667 }
1668
1669 if (r->res_master_nodeid != our_nodeid) {
1670 spin_unlock(&ls->ls_rsbtbl[b].lock);
1671 log_debug(ls, "remove_name master %d dir %d our %d %s",
1672 r->res_master_nodeid, r->res_dir_nodeid,
1673 our_nodeid, name);
1674 continue;
1675 }
1676
1677 if (r->res_dir_nodeid == our_nodeid) {
1678 /* should never happen */
1679 spin_unlock(&ls->ls_rsbtbl[b].lock);
1680 log_error(ls, "remove_name dir %d master %d our %d %s",
1681 r->res_dir_nodeid, r->res_master_nodeid,
1682 our_nodeid, name);
1683 continue;
1684 }
1685
1686 if (!time_after_eq(jiffies, r->res_toss_time +
1687 dlm_config.ci_toss_secs * HZ)) {
1688 spin_unlock(&ls->ls_rsbtbl[b].lock);
1689 log_debug(ls, "remove_name toss_time %lu now %lu %s",
1690 r->res_toss_time, jiffies, name);
1691 continue;
1692 }
1693
1694 if (!kref_put(&r->res_ref, kill_rsb)) {
1695 spin_unlock(&ls->ls_rsbtbl[b].lock);
1696 log_error(ls, "remove_name in use %s", name);
1697 continue;
1698 }
1699
1700 rb_erase(&r->res_hashnode, &ls->ls_rsbtbl[b].toss);
1701 send_remove(r);
1702 spin_unlock(&ls->ls_rsbtbl[b].lock);
1703
1704 dlm_free_rsb(r);
1705 }
1706}
1707
1708void dlm_scan_rsbs(struct dlm_ls *ls)
1709{
1710 int i;
1711
1712 for (i = 0; i < ls->ls_rsbtbl_size; i++) {
1713 shrink_bucket(ls, i);
1714 if (dlm_locking_stopped(ls))
1715 break;
1716 cond_resched();
1717 }
1718}
1719
1720/* lkb is master or local copy */
1721
1722static void set_lvb_lock(struct dlm_rsb *r, struct dlm_lkb *lkb)
1723{
1724 int b, len = r->res_ls->ls_lvblen;
1725
1726 /* b=1 lvb returned to caller
1727 b=0 lvb written to rsb or invalidated
1728 b=-1 do nothing */
1729
1730 b = dlm_lvb_operations[lkb->lkb_grmode + 1][lkb->lkb_rqmode + 1];
1731
1732 if (b == 1) {
1733 if (!lkb->lkb_lvbptr)
1734 return;
1735
1736 if (!(lkb->lkb_exflags & DLM_LKF_VALBLK))
1737 return;
1738
1739 if (!r->res_lvbptr)
1740 return;
1741
1742 memcpy(lkb->lkb_lvbptr, r->res_lvbptr, len);
1743 lkb->lkb_lvbseq = r->res_lvbseq;
1744
1745 } else if (b == 0) {
1746 if (lkb->lkb_exflags & DLM_LKF_IVVALBLK) {
1747 rsb_set_flag(r, RSB_VALNOTVALID);
1748 return;
1749 }
1750
1751 if (!lkb->lkb_lvbptr)
1752 return;
1753
1754 if (!(lkb->lkb_exflags & DLM_LKF_VALBLK))
1755 return;
1756
1757 if (!r->res_lvbptr)
1758 r->res_lvbptr = dlm_allocate_lvb(r->res_ls);
1759
1760 if (!r->res_lvbptr)
1761 return;
1762
1763 memcpy(r->res_lvbptr, lkb->lkb_lvbptr, len);
1764 r->res_lvbseq++;
1765 lkb->lkb_lvbseq = r->res_lvbseq;
1766 rsb_clear_flag(r, RSB_VALNOTVALID);
1767 }
1768
1769 if (rsb_flag(r, RSB_VALNOTVALID))
1770 set_bit(DLM_SBF_VALNOTVALID_BIT, &lkb->lkb_sbflags);
1771}
1772
1773static void set_lvb_unlock(struct dlm_rsb *r, struct dlm_lkb *lkb)
1774{
1775 if (lkb->lkb_grmode < DLM_LOCK_PW)
1776 return;
1777
1778 if (lkb->lkb_exflags & DLM_LKF_IVVALBLK) {
1779 rsb_set_flag(r, RSB_VALNOTVALID);
1780 return;
1781 }
1782
1783 if (!lkb->lkb_lvbptr)
1784 return;
1785
1786 if (!(lkb->lkb_exflags & DLM_LKF_VALBLK))
1787 return;
1788
1789 if (!r->res_lvbptr)
1790 r->res_lvbptr = dlm_allocate_lvb(r->res_ls);
1791
1792 if (!r->res_lvbptr)
1793 return;
1794
1795 memcpy(r->res_lvbptr, lkb->lkb_lvbptr, r->res_ls->ls_lvblen);
1796 r->res_lvbseq++;
1797 rsb_clear_flag(r, RSB_VALNOTVALID);
1798}
1799
1800/* lkb is process copy (pc) */
1801
1802static void set_lvb_lock_pc(struct dlm_rsb *r, struct dlm_lkb *lkb,
1803 const struct dlm_message *ms)
1804{
1805 int b;
1806
1807 if (!lkb->lkb_lvbptr)
1808 return;
1809
1810 if (!(lkb->lkb_exflags & DLM_LKF_VALBLK))
1811 return;
1812
1813 b = dlm_lvb_operations[lkb->lkb_grmode + 1][lkb->lkb_rqmode + 1];
1814 if (b == 1) {
1815 int len = receive_extralen(ms);
1816 if (len > r->res_ls->ls_lvblen)
1817 len = r->res_ls->ls_lvblen;
1818 memcpy(lkb->lkb_lvbptr, ms->m_extra, len);
1819 lkb->lkb_lvbseq = le32_to_cpu(ms->m_lvbseq);
1820 }
1821}
1822
1823/* Manipulate lkb's on rsb's convert/granted/waiting queues
1824 remove_lock -- used for unlock, removes lkb from granted
1825 revert_lock -- used for cancel, moves lkb from convert to granted
1826 grant_lock -- used for request and convert, adds lkb to granted or
1827 moves lkb from convert or waiting to granted
1828
1829 Each of these is used for master or local copy lkb's. There is
1830 also a _pc() variation used to make the corresponding change on
1831 a process copy (pc) lkb. */
1832
1833static void _remove_lock(struct dlm_rsb *r, struct dlm_lkb *lkb)
1834{
1835 del_lkb(r, lkb);
1836 lkb->lkb_grmode = DLM_LOCK_IV;
1837 /* this unhold undoes the original ref from create_lkb()
1838 so this leads to the lkb being freed */
1839 unhold_lkb(lkb);
1840}
1841
1842static void remove_lock(struct dlm_rsb *r, struct dlm_lkb *lkb)
1843{
1844 set_lvb_unlock(r, lkb);
1845 _remove_lock(r, lkb);
1846}
1847
1848static void remove_lock_pc(struct dlm_rsb *r, struct dlm_lkb *lkb)
1849{
1850 _remove_lock(r, lkb);
1851}
1852
1853/* returns: 0 did nothing
1854 1 moved lock to granted
1855 -1 removed lock */
1856
1857static int revert_lock(struct dlm_rsb *r, struct dlm_lkb *lkb)
1858{
1859 int rv = 0;
1860
1861 lkb->lkb_rqmode = DLM_LOCK_IV;
1862
1863 switch (lkb->lkb_status) {
1864 case DLM_LKSTS_GRANTED:
1865 break;
1866 case DLM_LKSTS_CONVERT:
1867 move_lkb(r, lkb, DLM_LKSTS_GRANTED);
1868 rv = 1;
1869 break;
1870 case DLM_LKSTS_WAITING:
1871 del_lkb(r, lkb);
1872 lkb->lkb_grmode = DLM_LOCK_IV;
1873 /* this unhold undoes the original ref from create_lkb()
1874 so this leads to the lkb being freed */
1875 unhold_lkb(lkb);
1876 rv = -1;
1877 break;
1878 default:
1879 log_print("invalid status for revert %d", lkb->lkb_status);
1880 }
1881 return rv;
1882}
1883
1884static int revert_lock_pc(struct dlm_rsb *r, struct dlm_lkb *lkb)
1885{
1886 return revert_lock(r, lkb);
1887}
1888
1889static void _grant_lock(struct dlm_rsb *r, struct dlm_lkb *lkb)
1890{
1891 if (lkb->lkb_grmode != lkb->lkb_rqmode) {
1892 lkb->lkb_grmode = lkb->lkb_rqmode;
1893 if (lkb->lkb_status)
1894 move_lkb(r, lkb, DLM_LKSTS_GRANTED);
1895 else
1896 add_lkb(r, lkb, DLM_LKSTS_GRANTED);
1897 }
1898
1899 lkb->lkb_rqmode = DLM_LOCK_IV;
1900 lkb->lkb_highbast = 0;
1901}
1902
1903static void grant_lock(struct dlm_rsb *r, struct dlm_lkb *lkb)
1904{
1905 set_lvb_lock(r, lkb);
1906 _grant_lock(r, lkb);
1907}
1908
1909static void grant_lock_pc(struct dlm_rsb *r, struct dlm_lkb *lkb,
1910 const struct dlm_message *ms)
1911{
1912 set_lvb_lock_pc(r, lkb, ms);
1913 _grant_lock(r, lkb);
1914}
1915
1916/* called by grant_pending_locks() which means an async grant message must
1917 be sent to the requesting node in addition to granting the lock if the
1918 lkb belongs to a remote node. */
1919
1920static void grant_lock_pending(struct dlm_rsb *r, struct dlm_lkb *lkb)
1921{
1922 grant_lock(r, lkb);
1923 if (is_master_copy(lkb))
1924 send_grant(r, lkb);
1925 else
1926 queue_cast(r, lkb, 0);
1927}
1928
1929/* The special CONVDEADLK, ALTPR and ALTCW flags allow the master to
1930 change the granted/requested modes. We're munging things accordingly in
1931 the process copy.
1932 CONVDEADLK: our grmode may have been forced down to NL to resolve a
1933 conversion deadlock
1934 ALTPR/ALTCW: our rqmode may have been changed to PR or CW to become
1935 compatible with other granted locks */
1936
1937static void munge_demoted(struct dlm_lkb *lkb)
1938{
1939 if (lkb->lkb_rqmode == DLM_LOCK_IV || lkb->lkb_grmode == DLM_LOCK_IV) {
1940 log_print("munge_demoted %x invalid modes gr %d rq %d",
1941 lkb->lkb_id, lkb->lkb_grmode, lkb->lkb_rqmode);
1942 return;
1943 }
1944
1945 lkb->lkb_grmode = DLM_LOCK_NL;
1946}
1947
1948static void munge_altmode(struct dlm_lkb *lkb, const struct dlm_message *ms)
1949{
1950 if (ms->m_type != cpu_to_le32(DLM_MSG_REQUEST_REPLY) &&
1951 ms->m_type != cpu_to_le32(DLM_MSG_GRANT)) {
1952 log_print("munge_altmode %x invalid reply type %d",
1953 lkb->lkb_id, le32_to_cpu(ms->m_type));
1954 return;
1955 }
1956
1957 if (lkb->lkb_exflags & DLM_LKF_ALTPR)
1958 lkb->lkb_rqmode = DLM_LOCK_PR;
1959 else if (lkb->lkb_exflags & DLM_LKF_ALTCW)
1960 lkb->lkb_rqmode = DLM_LOCK_CW;
1961 else {
1962 log_print("munge_altmode invalid exflags %x", lkb->lkb_exflags);
1963 dlm_print_lkb(lkb);
1964 }
1965}
1966
1967static inline int first_in_list(struct dlm_lkb *lkb, struct list_head *head)
1968{
1969 struct dlm_lkb *first = list_entry(head->next, struct dlm_lkb,
1970 lkb_statequeue);
1971 if (lkb->lkb_id == first->lkb_id)
1972 return 1;
1973
1974 return 0;
1975}
1976
1977/* Check if the given lkb conflicts with another lkb on the queue. */
1978
1979static int queue_conflict(struct list_head *head, struct dlm_lkb *lkb)
1980{
1981 struct dlm_lkb *this;
1982
1983 list_for_each_entry(this, head, lkb_statequeue) {
1984 if (this == lkb)
1985 continue;
1986 if (!modes_compat(this, lkb))
1987 return 1;
1988 }
1989 return 0;
1990}
1991
1992/*
1993 * "A conversion deadlock arises with a pair of lock requests in the converting
1994 * queue for one resource. The granted mode of each lock blocks the requested
1995 * mode of the other lock."
1996 *
1997 * Part 2: if the granted mode of lkb is preventing an earlier lkb in the
1998 * convert queue from being granted, then deadlk/demote lkb.
1999 *
2000 * Example:
2001 * Granted Queue: empty
2002 * Convert Queue: NL->EX (first lock)
2003 * PR->EX (second lock)
2004 *
2005 * The first lock can't be granted because of the granted mode of the second
2006 * lock and the second lock can't be granted because it's not first in the
2007 * list. We either cancel lkb's conversion (PR->EX) and return EDEADLK, or we
2008 * demote the granted mode of lkb (from PR to NL) if it has the CONVDEADLK
2009 * flag set and return DEMOTED in the lksb flags.
2010 *
2011 * Originally, this function detected conv-deadlk in a more limited scope:
2012 * - if !modes_compat(lkb1, lkb2) && !modes_compat(lkb2, lkb1), or
2013 * - if lkb1 was the first entry in the queue (not just earlier), and was
2014 * blocked by the granted mode of lkb2, and there was nothing on the
2015 * granted queue preventing lkb1 from being granted immediately, i.e.
2016 * lkb2 was the only thing preventing lkb1 from being granted.
2017 *
2018 * That second condition meant we'd only say there was conv-deadlk if
2019 * resolving it (by demotion) would lead to the first lock on the convert
2020 * queue being granted right away. It allowed conversion deadlocks to exist
2021 * between locks on the convert queue while they couldn't be granted anyway.
2022 *
2023 * Now, we detect and take action on conversion deadlocks immediately when
2024 * they're created, even if they may not be immediately consequential. If
2025 * lkb1 exists anywhere in the convert queue and lkb2 comes in with a granted
2026 * mode that would prevent lkb1's conversion from being granted, we do a
2027 * deadlk/demote on lkb2 right away and don't let it onto the convert queue.
2028 * I think this means that the lkb_is_ahead condition below should always
2029 * be zero, i.e. there will never be conv-deadlk between two locks that are
2030 * both already on the convert queue.
2031 */
2032
2033static int conversion_deadlock_detect(struct dlm_rsb *r, struct dlm_lkb *lkb2)
2034{
2035 struct dlm_lkb *lkb1;
2036 int lkb_is_ahead = 0;
2037
2038 list_for_each_entry(lkb1, &r->res_convertqueue, lkb_statequeue) {
2039 if (lkb1 == lkb2) {
2040 lkb_is_ahead = 1;
2041 continue;
2042 }
2043
2044 if (!lkb_is_ahead) {
2045 if (!modes_compat(lkb2, lkb1))
2046 return 1;
2047 } else {
2048 if (!modes_compat(lkb2, lkb1) &&
2049 !modes_compat(lkb1, lkb2))
2050 return 1;
2051 }
2052 }
2053 return 0;
2054}
2055
2056/*
2057 * Return 1 if the lock can be granted, 0 otherwise.
2058 * Also detect and resolve conversion deadlocks.
2059 *
2060 * lkb is the lock to be granted
2061 *
2062 * now is 1 if the function is being called in the context of the
2063 * immediate request, it is 0 if called later, after the lock has been
2064 * queued.
2065 *
2066 * recover is 1 if dlm_recover_grant() is trying to grant conversions
2067 * after recovery.
2068 *
2069 * References are from chapter 6 of "VAXcluster Principles" by Roy Davis
2070 */
2071
2072static int _can_be_granted(struct dlm_rsb *r, struct dlm_lkb *lkb, int now,
2073 int recover)
2074{
2075 int8_t conv = (lkb->lkb_grmode != DLM_LOCK_IV);
2076
2077 /*
2078 * 6-10: Version 5.4 introduced an option to address the phenomenon of
2079 * a new request for a NL mode lock being blocked.
2080 *
2081 * 6-11: If the optional EXPEDITE flag is used with the new NL mode
2082 * request, then it would be granted. In essence, the use of this flag
2083 * tells the Lock Manager to expedite theis request by not considering
2084 * what may be in the CONVERTING or WAITING queues... As of this
2085 * writing, the EXPEDITE flag can be used only with new requests for NL
2086 * mode locks. This flag is not valid for conversion requests.
2087 *
2088 * A shortcut. Earlier checks return an error if EXPEDITE is used in a
2089 * conversion or used with a non-NL requested mode. We also know an
2090 * EXPEDITE request is always granted immediately, so now must always
2091 * be 1. The full condition to grant an expedite request: (now &&
2092 * !conv && lkb->rqmode == DLM_LOCK_NL && (flags & EXPEDITE)) can
2093 * therefore be shortened to just checking the flag.
2094 */
2095
2096 if (lkb->lkb_exflags & DLM_LKF_EXPEDITE)
2097 return 1;
2098
2099 /*
2100 * A shortcut. Without this, !queue_conflict(grantqueue, lkb) would be
2101 * added to the remaining conditions.
2102 */
2103
2104 if (queue_conflict(&r->res_grantqueue, lkb))
2105 return 0;
2106
2107 /*
2108 * 6-3: By default, a conversion request is immediately granted if the
2109 * requested mode is compatible with the modes of all other granted
2110 * locks
2111 */
2112
2113 if (queue_conflict(&r->res_convertqueue, lkb))
2114 return 0;
2115
2116 /*
2117 * The RECOVER_GRANT flag means dlm_recover_grant() is granting
2118 * locks for a recovered rsb, on which lkb's have been rebuilt.
2119 * The lkb's may have been rebuilt on the queues in a different
2120 * order than they were in on the previous master. So, granting
2121 * queued conversions in order after recovery doesn't make sense
2122 * since the order hasn't been preserved anyway. The new order
2123 * could also have created a new "in place" conversion deadlock.
2124 * (e.g. old, failed master held granted EX, with PR->EX, NL->EX.
2125 * After recovery, there would be no granted locks, and possibly
2126 * NL->EX, PR->EX, an in-place conversion deadlock.) So, after
2127 * recovery, grant conversions without considering order.
2128 */
2129
2130 if (conv && recover)
2131 return 1;
2132
2133 /*
2134 * 6-5: But the default algorithm for deciding whether to grant or
2135 * queue conversion requests does not by itself guarantee that such
2136 * requests are serviced on a "first come first serve" basis. This, in
2137 * turn, can lead to a phenomenon known as "indefinate postponement".
2138 *
2139 * 6-7: This issue is dealt with by using the optional QUECVT flag with
2140 * the system service employed to request a lock conversion. This flag
2141 * forces certain conversion requests to be queued, even if they are
2142 * compatible with the granted modes of other locks on the same
2143 * resource. Thus, the use of this flag results in conversion requests
2144 * being ordered on a "first come first servce" basis.
2145 *
2146 * DCT: This condition is all about new conversions being able to occur
2147 * "in place" while the lock remains on the granted queue (assuming
2148 * nothing else conflicts.) IOW if QUECVT isn't set, a conversion
2149 * doesn't _have_ to go onto the convert queue where it's processed in
2150 * order. The "now" variable is necessary to distinguish converts
2151 * being received and processed for the first time now, because once a
2152 * convert is moved to the conversion queue the condition below applies
2153 * requiring fifo granting.
2154 */
2155
2156 if (now && conv && !(lkb->lkb_exflags & DLM_LKF_QUECVT))
2157 return 1;
2158
2159 /*
2160 * Even if the convert is compat with all granted locks,
2161 * QUECVT forces it behind other locks on the convert queue.
2162 */
2163
2164 if (now && conv && (lkb->lkb_exflags & DLM_LKF_QUECVT)) {
2165 if (list_empty(&r->res_convertqueue))
2166 return 1;
2167 else
2168 return 0;
2169 }
2170
2171 /*
2172 * The NOORDER flag is set to avoid the standard vms rules on grant
2173 * order.
2174 */
2175
2176 if (lkb->lkb_exflags & DLM_LKF_NOORDER)
2177 return 1;
2178
2179 /*
2180 * 6-3: Once in that queue [CONVERTING], a conversion request cannot be
2181 * granted until all other conversion requests ahead of it are granted
2182 * and/or canceled.
2183 */
2184
2185 if (!now && conv && first_in_list(lkb, &r->res_convertqueue))
2186 return 1;
2187
2188 /*
2189 * 6-4: By default, a new request is immediately granted only if all
2190 * three of the following conditions are satisfied when the request is
2191 * issued:
2192 * - The queue of ungranted conversion requests for the resource is
2193 * empty.
2194 * - The queue of ungranted new requests for the resource is empty.
2195 * - The mode of the new request is compatible with the most
2196 * restrictive mode of all granted locks on the resource.
2197 */
2198
2199 if (now && !conv && list_empty(&r->res_convertqueue) &&
2200 list_empty(&r->res_waitqueue))
2201 return 1;
2202
2203 /*
2204 * 6-4: Once a lock request is in the queue of ungranted new requests,
2205 * it cannot be granted until the queue of ungranted conversion
2206 * requests is empty, all ungranted new requests ahead of it are
2207 * granted and/or canceled, and it is compatible with the granted mode
2208 * of the most restrictive lock granted on the resource.
2209 */
2210
2211 if (!now && !conv && list_empty(&r->res_convertqueue) &&
2212 first_in_list(lkb, &r->res_waitqueue))
2213 return 1;
2214
2215 return 0;
2216}
2217
2218static int can_be_granted(struct dlm_rsb *r, struct dlm_lkb *lkb, int now,
2219 int recover, int *err)
2220{
2221 int rv;
2222 int8_t alt = 0, rqmode = lkb->lkb_rqmode;
2223 int8_t is_convert = (lkb->lkb_grmode != DLM_LOCK_IV);
2224
2225 if (err)
2226 *err = 0;
2227
2228 rv = _can_be_granted(r, lkb, now, recover);
2229 if (rv)
2230 goto out;
2231
2232 /*
2233 * The CONVDEADLK flag is non-standard and tells the dlm to resolve
2234 * conversion deadlocks by demoting grmode to NL, otherwise the dlm
2235 * cancels one of the locks.
2236 */
2237
2238 if (is_convert && can_be_queued(lkb) &&
2239 conversion_deadlock_detect(r, lkb)) {
2240 if (lkb->lkb_exflags & DLM_LKF_CONVDEADLK) {
2241 lkb->lkb_grmode = DLM_LOCK_NL;
2242 set_bit(DLM_SBF_DEMOTED_BIT, &lkb->lkb_sbflags);
2243 } else if (err) {
2244 *err = -EDEADLK;
2245 } else {
2246 log_print("can_be_granted deadlock %x now %d",
2247 lkb->lkb_id, now);
2248 dlm_dump_rsb(r);
2249 }
2250 goto out;
2251 }
2252
2253 /*
2254 * The ALTPR and ALTCW flags are non-standard and tell the dlm to try
2255 * to grant a request in a mode other than the normal rqmode. It's a
2256 * simple way to provide a big optimization to applications that can
2257 * use them.
2258 */
2259
2260 if (rqmode != DLM_LOCK_PR && (lkb->lkb_exflags & DLM_LKF_ALTPR))
2261 alt = DLM_LOCK_PR;
2262 else if (rqmode != DLM_LOCK_CW && (lkb->lkb_exflags & DLM_LKF_ALTCW))
2263 alt = DLM_LOCK_CW;
2264
2265 if (alt) {
2266 lkb->lkb_rqmode = alt;
2267 rv = _can_be_granted(r, lkb, now, 0);
2268 if (rv)
2269 set_bit(DLM_SBF_ALTMODE_BIT, &lkb->lkb_sbflags);
2270 else
2271 lkb->lkb_rqmode = rqmode;
2272 }
2273 out:
2274 return rv;
2275}
2276
2277/* Returns the highest requested mode of all blocked conversions; sets
2278 cw if there's a blocked conversion to DLM_LOCK_CW. */
2279
2280static int grant_pending_convert(struct dlm_rsb *r, int high, int *cw,
2281 unsigned int *count)
2282{
2283 struct dlm_lkb *lkb, *s;
2284 int recover = rsb_flag(r, RSB_RECOVER_GRANT);
2285 int hi, demoted, quit, grant_restart, demote_restart;
2286 int deadlk;
2287
2288 quit = 0;
2289 restart:
2290 grant_restart = 0;
2291 demote_restart = 0;
2292 hi = DLM_LOCK_IV;
2293
2294 list_for_each_entry_safe(lkb, s, &r->res_convertqueue, lkb_statequeue) {
2295 demoted = is_demoted(lkb);
2296 deadlk = 0;
2297
2298 if (can_be_granted(r, lkb, 0, recover, &deadlk)) {
2299 grant_lock_pending(r, lkb);
2300 grant_restart = 1;
2301 if (count)
2302 (*count)++;
2303 continue;
2304 }
2305
2306 if (!demoted && is_demoted(lkb)) {
2307 log_print("WARN: pending demoted %x node %d %s",
2308 lkb->lkb_id, lkb->lkb_nodeid, r->res_name);
2309 demote_restart = 1;
2310 continue;
2311 }
2312
2313 if (deadlk) {
2314 /*
2315 * If DLM_LKB_NODLKWT flag is set and conversion
2316 * deadlock is detected, we request blocking AST and
2317 * down (or cancel) conversion.
2318 */
2319 if (lkb->lkb_exflags & DLM_LKF_NODLCKWT) {
2320 if (lkb->lkb_highbast < lkb->lkb_rqmode) {
2321 queue_bast(r, lkb, lkb->lkb_rqmode);
2322 lkb->lkb_highbast = lkb->lkb_rqmode;
2323 }
2324 } else {
2325 log_print("WARN: pending deadlock %x node %d %s",
2326 lkb->lkb_id, lkb->lkb_nodeid,
2327 r->res_name);
2328 dlm_dump_rsb(r);
2329 }
2330 continue;
2331 }
2332
2333 hi = max_t(int, lkb->lkb_rqmode, hi);
2334
2335 if (cw && lkb->lkb_rqmode == DLM_LOCK_CW)
2336 *cw = 1;
2337 }
2338
2339 if (grant_restart)
2340 goto restart;
2341 if (demote_restart && !quit) {
2342 quit = 1;
2343 goto restart;
2344 }
2345
2346 return max_t(int, high, hi);
2347}
2348
2349static int grant_pending_wait(struct dlm_rsb *r, int high, int *cw,
2350 unsigned int *count)
2351{
2352 struct dlm_lkb *lkb, *s;
2353
2354 list_for_each_entry_safe(lkb, s, &r->res_waitqueue, lkb_statequeue) {
2355 if (can_be_granted(r, lkb, 0, 0, NULL)) {
2356 grant_lock_pending(r, lkb);
2357 if (count)
2358 (*count)++;
2359 } else {
2360 high = max_t(int, lkb->lkb_rqmode, high);
2361 if (lkb->lkb_rqmode == DLM_LOCK_CW)
2362 *cw = 1;
2363 }
2364 }
2365
2366 return high;
2367}
2368
2369/* cw of 1 means there's a lock with a rqmode of DLM_LOCK_CW that's blocked
2370 on either the convert or waiting queue.
2371 high is the largest rqmode of all locks blocked on the convert or
2372 waiting queue. */
2373
2374static int lock_requires_bast(struct dlm_lkb *gr, int high, int cw)
2375{
2376 if (gr->lkb_grmode == DLM_LOCK_PR && cw) {
2377 if (gr->lkb_highbast < DLM_LOCK_EX)
2378 return 1;
2379 return 0;
2380 }
2381
2382 if (gr->lkb_highbast < high &&
2383 !__dlm_compat_matrix[gr->lkb_grmode+1][high+1])
2384 return 1;
2385 return 0;
2386}
2387
2388static void grant_pending_locks(struct dlm_rsb *r, unsigned int *count)
2389{
2390 struct dlm_lkb *lkb, *s;
2391 int high = DLM_LOCK_IV;
2392 int cw = 0;
2393
2394 if (!is_master(r)) {
2395 log_print("grant_pending_locks r nodeid %d", r->res_nodeid);
2396 dlm_dump_rsb(r);
2397 return;
2398 }
2399
2400 high = grant_pending_convert(r, high, &cw, count);
2401 high = grant_pending_wait(r, high, &cw, count);
2402
2403 if (high == DLM_LOCK_IV)
2404 return;
2405
2406 /*
2407 * If there are locks left on the wait/convert queue then send blocking
2408 * ASTs to granted locks based on the largest requested mode (high)
2409 * found above.
2410 */
2411
2412 list_for_each_entry_safe(lkb, s, &r->res_grantqueue, lkb_statequeue) {
2413 if (lkb->lkb_bastfn && lock_requires_bast(lkb, high, cw)) {
2414 if (cw && high == DLM_LOCK_PR &&
2415 lkb->lkb_grmode == DLM_LOCK_PR)
2416 queue_bast(r, lkb, DLM_LOCK_CW);
2417 else
2418 queue_bast(r, lkb, high);
2419 lkb->lkb_highbast = high;
2420 }
2421 }
2422}
2423
2424static int modes_require_bast(struct dlm_lkb *gr, struct dlm_lkb *rq)
2425{
2426 if ((gr->lkb_grmode == DLM_LOCK_PR && rq->lkb_rqmode == DLM_LOCK_CW) ||
2427 (gr->lkb_grmode == DLM_LOCK_CW && rq->lkb_rqmode == DLM_LOCK_PR)) {
2428 if (gr->lkb_highbast < DLM_LOCK_EX)
2429 return 1;
2430 return 0;
2431 }
2432
2433 if (gr->lkb_highbast < rq->lkb_rqmode && !modes_compat(gr, rq))
2434 return 1;
2435 return 0;
2436}
2437
2438static void send_bast_queue(struct dlm_rsb *r, struct list_head *head,
2439 struct dlm_lkb *lkb)
2440{
2441 struct dlm_lkb *gr;
2442
2443 list_for_each_entry(gr, head, lkb_statequeue) {
2444 /* skip self when sending basts to convertqueue */
2445 if (gr == lkb)
2446 continue;
2447 if (gr->lkb_bastfn && modes_require_bast(gr, lkb)) {
2448 queue_bast(r, gr, lkb->lkb_rqmode);
2449 gr->lkb_highbast = lkb->lkb_rqmode;
2450 }
2451 }
2452}
2453
2454static void send_blocking_asts(struct dlm_rsb *r, struct dlm_lkb *lkb)
2455{
2456 send_bast_queue(r, &r->res_grantqueue, lkb);
2457}
2458
2459static void send_blocking_asts_all(struct dlm_rsb *r, struct dlm_lkb *lkb)
2460{
2461 send_bast_queue(r, &r->res_grantqueue, lkb);
2462 send_bast_queue(r, &r->res_convertqueue, lkb);
2463}
2464
2465/* set_master(r, lkb) -- set the master nodeid of a resource
2466
2467 The purpose of this function is to set the nodeid field in the given
2468 lkb using the nodeid field in the given rsb. If the rsb's nodeid is
2469 known, it can just be copied to the lkb and the function will return
2470 0. If the rsb's nodeid is _not_ known, it needs to be looked up
2471 before it can be copied to the lkb.
2472
2473 When the rsb nodeid is being looked up remotely, the initial lkb
2474 causing the lookup is kept on the ls_waiters list waiting for the
2475 lookup reply. Other lkb's waiting for the same rsb lookup are kept
2476 on the rsb's res_lookup list until the master is verified.
2477
2478 Return values:
2479 0: nodeid is set in rsb/lkb and the caller should go ahead and use it
2480 1: the rsb master is not available and the lkb has been placed on
2481 a wait queue
2482*/
2483
2484static int set_master(struct dlm_rsb *r, struct dlm_lkb *lkb)
2485{
2486 int our_nodeid = dlm_our_nodeid();
2487
2488 if (rsb_flag(r, RSB_MASTER_UNCERTAIN)) {
2489 rsb_clear_flag(r, RSB_MASTER_UNCERTAIN);
2490 r->res_first_lkid = lkb->lkb_id;
2491 lkb->lkb_nodeid = r->res_nodeid;
2492 return 0;
2493 }
2494
2495 if (r->res_first_lkid && r->res_first_lkid != lkb->lkb_id) {
2496 list_add_tail(&lkb->lkb_rsb_lookup, &r->res_lookup);
2497 return 1;
2498 }
2499
2500 if (r->res_master_nodeid == our_nodeid) {
2501 lkb->lkb_nodeid = 0;
2502 return 0;
2503 }
2504
2505 if (r->res_master_nodeid) {
2506 lkb->lkb_nodeid = r->res_master_nodeid;
2507 return 0;
2508 }
2509
2510 if (dlm_dir_nodeid(r) == our_nodeid) {
2511 /* This is a somewhat unusual case; find_rsb will usually
2512 have set res_master_nodeid when dir nodeid is local, but
2513 there are cases where we become the dir node after we've
2514 past find_rsb and go through _request_lock again.
2515 confirm_master() or process_lookup_list() needs to be
2516 called after this. */
2517 log_debug(r->res_ls, "set_master %x self master %d dir %d %s",
2518 lkb->lkb_id, r->res_master_nodeid, r->res_dir_nodeid,
2519 r->res_name);
2520 r->res_master_nodeid = our_nodeid;
2521 r->res_nodeid = 0;
2522 lkb->lkb_nodeid = 0;
2523 return 0;
2524 }
2525
2526 r->res_first_lkid = lkb->lkb_id;
2527 send_lookup(r, lkb);
2528 return 1;
2529}
2530
2531static void process_lookup_list(struct dlm_rsb *r)
2532{
2533 struct dlm_lkb *lkb, *safe;
2534
2535 list_for_each_entry_safe(lkb, safe, &r->res_lookup, lkb_rsb_lookup) {
2536 list_del_init(&lkb->lkb_rsb_lookup);
2537 _request_lock(r, lkb);
2538 schedule();
2539 }
2540}
2541
2542/* confirm_master -- confirm (or deny) an rsb's master nodeid */
2543
2544static void confirm_master(struct dlm_rsb *r, int error)
2545{
2546 struct dlm_lkb *lkb;
2547
2548 if (!r->res_first_lkid)
2549 return;
2550
2551 switch (error) {
2552 case 0:
2553 case -EINPROGRESS:
2554 r->res_first_lkid = 0;
2555 process_lookup_list(r);
2556 break;
2557
2558 case -EAGAIN:
2559 case -EBADR:
2560 case -ENOTBLK:
2561 /* the remote request failed and won't be retried (it was
2562 a NOQUEUE, or has been canceled/unlocked); make a waiting
2563 lkb the first_lkid */
2564
2565 r->res_first_lkid = 0;
2566
2567 if (!list_empty(&r->res_lookup)) {
2568 lkb = list_entry(r->res_lookup.next, struct dlm_lkb,
2569 lkb_rsb_lookup);
2570 list_del_init(&lkb->lkb_rsb_lookup);
2571 r->res_first_lkid = lkb->lkb_id;
2572 _request_lock(r, lkb);
2573 }
2574 break;
2575
2576 default:
2577 log_error(r->res_ls, "confirm_master unknown error %d", error);
2578 }
2579}
2580
2581static int set_lock_args(int mode, struct dlm_lksb *lksb, uint32_t flags,
2582 int namelen, void (*ast)(void *astparam),
2583 void *astparam,
2584 void (*bast)(void *astparam, int mode),
2585 struct dlm_args *args)
2586{
2587 int rv = -EINVAL;
2588
2589 /* check for invalid arg usage */
2590
2591 if (mode < 0 || mode > DLM_LOCK_EX)
2592 goto out;
2593
2594 if (!(flags & DLM_LKF_CONVERT) && (namelen > DLM_RESNAME_MAXLEN))
2595 goto out;
2596
2597 if (flags & DLM_LKF_CANCEL)
2598 goto out;
2599
2600 if (flags & DLM_LKF_QUECVT && !(flags & DLM_LKF_CONVERT))
2601 goto out;
2602
2603 if (flags & DLM_LKF_CONVDEADLK && !(flags & DLM_LKF_CONVERT))
2604 goto out;
2605
2606 if (flags & DLM_LKF_CONVDEADLK && flags & DLM_LKF_NOQUEUE)
2607 goto out;
2608
2609 if (flags & DLM_LKF_EXPEDITE && flags & DLM_LKF_CONVERT)
2610 goto out;
2611
2612 if (flags & DLM_LKF_EXPEDITE && flags & DLM_LKF_QUECVT)
2613 goto out;
2614
2615 if (flags & DLM_LKF_EXPEDITE && flags & DLM_LKF_NOQUEUE)
2616 goto out;
2617
2618 if (flags & DLM_LKF_EXPEDITE && mode != DLM_LOCK_NL)
2619 goto out;
2620
2621 if (!ast || !lksb)
2622 goto out;
2623
2624 if (flags & DLM_LKF_VALBLK && !lksb->sb_lvbptr)
2625 goto out;
2626
2627 if (flags & DLM_LKF_CONVERT && !lksb->sb_lkid)
2628 goto out;
2629
2630 /* these args will be copied to the lkb in validate_lock_args,
2631 it cannot be done now because when converting locks, fields in
2632 an active lkb cannot be modified before locking the rsb */
2633
2634 args->flags = flags;
2635 args->astfn = ast;
2636 args->astparam = astparam;
2637 args->bastfn = bast;
2638 args->mode = mode;
2639 args->lksb = lksb;
2640 rv = 0;
2641 out:
2642 return rv;
2643}
2644
2645static int set_unlock_args(uint32_t flags, void *astarg, struct dlm_args *args)
2646{
2647 if (flags & ~(DLM_LKF_CANCEL | DLM_LKF_VALBLK | DLM_LKF_IVVALBLK |
2648 DLM_LKF_FORCEUNLOCK))
2649 return -EINVAL;
2650
2651 if (flags & DLM_LKF_CANCEL && flags & DLM_LKF_FORCEUNLOCK)
2652 return -EINVAL;
2653
2654 args->flags = flags;
2655 args->astparam = astarg;
2656 return 0;
2657}
2658
2659static int validate_lock_args(struct dlm_ls *ls, struct dlm_lkb *lkb,
2660 struct dlm_args *args)
2661{
2662 int rv = -EBUSY;
2663
2664 if (args->flags & DLM_LKF_CONVERT) {
2665 if (lkb->lkb_status != DLM_LKSTS_GRANTED)
2666 goto out;
2667
2668 /* lock not allowed if there's any op in progress */
2669 if (lkb->lkb_wait_type || atomic_read(&lkb->lkb_wait_count))
2670 goto out;
2671
2672 if (is_overlap(lkb))
2673 goto out;
2674
2675 rv = -EINVAL;
2676 if (test_bit(DLM_IFL_MSTCPY_BIT, &lkb->lkb_iflags))
2677 goto out;
2678
2679 if (args->flags & DLM_LKF_QUECVT &&
2680 !__quecvt_compat_matrix[lkb->lkb_grmode+1][args->mode+1])
2681 goto out;
2682 }
2683
2684 lkb->lkb_exflags = args->flags;
2685 dlm_set_sbflags_val(lkb, 0);
2686 lkb->lkb_astfn = args->astfn;
2687 lkb->lkb_astparam = args->astparam;
2688 lkb->lkb_bastfn = args->bastfn;
2689 lkb->lkb_rqmode = args->mode;
2690 lkb->lkb_lksb = args->lksb;
2691 lkb->lkb_lvbptr = args->lksb->sb_lvbptr;
2692 lkb->lkb_ownpid = (int) current->pid;
2693 rv = 0;
2694 out:
2695 switch (rv) {
2696 case 0:
2697 break;
2698 case -EINVAL:
2699 /* annoy the user because dlm usage is wrong */
2700 WARN_ON(1);
2701 log_error(ls, "%s %d %x %x %x %d %d %s", __func__,
2702 rv, lkb->lkb_id, dlm_iflags_val(lkb), args->flags,
2703 lkb->lkb_status, lkb->lkb_wait_type,
2704 lkb->lkb_resource->res_name);
2705 break;
2706 default:
2707 log_debug(ls, "%s %d %x %x %x %d %d %s", __func__,
2708 rv, lkb->lkb_id, dlm_iflags_val(lkb), args->flags,
2709 lkb->lkb_status, lkb->lkb_wait_type,
2710 lkb->lkb_resource->res_name);
2711 break;
2712 }
2713
2714 return rv;
2715}
2716
2717/* when dlm_unlock() sees -EBUSY with CANCEL/FORCEUNLOCK it returns 0
2718 for success */
2719
2720/* note: it's valid for lkb_nodeid/res_nodeid to be -1 when we get here
2721 because there may be a lookup in progress and it's valid to do
2722 cancel/unlockf on it */
2723
2724static int validate_unlock_args(struct dlm_lkb *lkb, struct dlm_args *args)
2725{
2726 struct dlm_ls *ls = lkb->lkb_resource->res_ls;
2727 int rv = -EBUSY;
2728
2729 /* normal unlock not allowed if there's any op in progress */
2730 if (!(args->flags & (DLM_LKF_CANCEL | DLM_LKF_FORCEUNLOCK)) &&
2731 (lkb->lkb_wait_type || atomic_read(&lkb->lkb_wait_count)))
2732 goto out;
2733
2734 /* an lkb may be waiting for an rsb lookup to complete where the
2735 lookup was initiated by another lock */
2736
2737 if (!list_empty(&lkb->lkb_rsb_lookup)) {
2738 if (args->flags & (DLM_LKF_CANCEL | DLM_LKF_FORCEUNLOCK)) {
2739 log_debug(ls, "unlock on rsb_lookup %x", lkb->lkb_id);
2740 list_del_init(&lkb->lkb_rsb_lookup);
2741 queue_cast(lkb->lkb_resource, lkb,
2742 args->flags & DLM_LKF_CANCEL ?
2743 -DLM_ECANCEL : -DLM_EUNLOCK);
2744 unhold_lkb(lkb); /* undoes create_lkb() */
2745 }
2746 /* caller changes -EBUSY to 0 for CANCEL and FORCEUNLOCK */
2747 goto out;
2748 }
2749
2750 rv = -EINVAL;
2751 if (test_bit(DLM_IFL_MSTCPY_BIT, &lkb->lkb_iflags)) {
2752 log_error(ls, "unlock on MSTCPY %x", lkb->lkb_id);
2753 dlm_print_lkb(lkb);
2754 goto out;
2755 }
2756
2757 /* an lkb may still exist even though the lock is EOL'ed due to a
2758 * cancel, unlock or failed noqueue request; an app can't use these
2759 * locks; return same error as if the lkid had not been found at all
2760 */
2761
2762 if (test_bit(DLM_IFL_ENDOFLIFE_BIT, &lkb->lkb_iflags)) {
2763 log_debug(ls, "unlock on ENDOFLIFE %x", lkb->lkb_id);
2764 rv = -ENOENT;
2765 goto out;
2766 }
2767
2768 /* cancel not allowed with another cancel/unlock in progress */
2769
2770 if (args->flags & DLM_LKF_CANCEL) {
2771 if (lkb->lkb_exflags & DLM_LKF_CANCEL)
2772 goto out;
2773
2774 if (is_overlap(lkb))
2775 goto out;
2776
2777 if (test_bit(DLM_IFL_RESEND_BIT, &lkb->lkb_iflags)) {
2778 set_bit(DLM_IFL_OVERLAP_CANCEL_BIT, &lkb->lkb_iflags);
2779 rv = -EBUSY;
2780 goto out;
2781 }
2782
2783 /* there's nothing to cancel */
2784 if (lkb->lkb_status == DLM_LKSTS_GRANTED &&
2785 !lkb->lkb_wait_type) {
2786 rv = -EBUSY;
2787 goto out;
2788 }
2789
2790 switch (lkb->lkb_wait_type) {
2791 case DLM_MSG_LOOKUP:
2792 case DLM_MSG_REQUEST:
2793 set_bit(DLM_IFL_OVERLAP_CANCEL_BIT, &lkb->lkb_iflags);
2794 rv = -EBUSY;
2795 goto out;
2796 case DLM_MSG_UNLOCK:
2797 case DLM_MSG_CANCEL:
2798 goto out;
2799 }
2800 /* add_to_waiters() will set OVERLAP_CANCEL */
2801 goto out_ok;
2802 }
2803
2804 /* do we need to allow a force-unlock if there's a normal unlock
2805 already in progress? in what conditions could the normal unlock
2806 fail such that we'd want to send a force-unlock to be sure? */
2807
2808 if (args->flags & DLM_LKF_FORCEUNLOCK) {
2809 if (lkb->lkb_exflags & DLM_LKF_FORCEUNLOCK)
2810 goto out;
2811
2812 if (is_overlap_unlock(lkb))
2813 goto out;
2814
2815 if (test_bit(DLM_IFL_RESEND_BIT, &lkb->lkb_iflags)) {
2816 set_bit(DLM_IFL_OVERLAP_UNLOCK_BIT, &lkb->lkb_iflags);
2817 rv = -EBUSY;
2818 goto out;
2819 }
2820
2821 switch (lkb->lkb_wait_type) {
2822 case DLM_MSG_LOOKUP:
2823 case DLM_MSG_REQUEST:
2824 set_bit(DLM_IFL_OVERLAP_UNLOCK_BIT, &lkb->lkb_iflags);
2825 rv = -EBUSY;
2826 goto out;
2827 case DLM_MSG_UNLOCK:
2828 goto out;
2829 }
2830 /* add_to_waiters() will set OVERLAP_UNLOCK */
2831 }
2832
2833 out_ok:
2834 /* an overlapping op shouldn't blow away exflags from other op */
2835 lkb->lkb_exflags |= args->flags;
2836 dlm_set_sbflags_val(lkb, 0);
2837 lkb->lkb_astparam = args->astparam;
2838 rv = 0;
2839 out:
2840 switch (rv) {
2841 case 0:
2842 break;
2843 case -EINVAL:
2844 /* annoy the user because dlm usage is wrong */
2845 WARN_ON(1);
2846 log_error(ls, "%s %d %x %x %x %x %d %s", __func__, rv,
2847 lkb->lkb_id, dlm_iflags_val(lkb), lkb->lkb_exflags,
2848 args->flags, lkb->lkb_wait_type,
2849 lkb->lkb_resource->res_name);
2850 break;
2851 default:
2852 log_debug(ls, "%s %d %x %x %x %x %d %s", __func__, rv,
2853 lkb->lkb_id, dlm_iflags_val(lkb), lkb->lkb_exflags,
2854 args->flags, lkb->lkb_wait_type,
2855 lkb->lkb_resource->res_name);
2856 break;
2857 }
2858
2859 return rv;
2860}
2861
2862/*
2863 * Four stage 4 varieties:
2864 * do_request(), do_convert(), do_unlock(), do_cancel()
2865 * These are called on the master node for the given lock and
2866 * from the central locking logic.
2867 */
2868
2869static int do_request(struct dlm_rsb *r, struct dlm_lkb *lkb)
2870{
2871 int error = 0;
2872
2873 if (can_be_granted(r, lkb, 1, 0, NULL)) {
2874 grant_lock(r, lkb);
2875 queue_cast(r, lkb, 0);
2876 goto out;
2877 }
2878
2879 if (can_be_queued(lkb)) {
2880 error = -EINPROGRESS;
2881 add_lkb(r, lkb, DLM_LKSTS_WAITING);
2882 goto out;
2883 }
2884
2885 error = -EAGAIN;
2886 queue_cast(r, lkb, -EAGAIN);
2887 out:
2888 return error;
2889}
2890
2891static void do_request_effects(struct dlm_rsb *r, struct dlm_lkb *lkb,
2892 int error)
2893{
2894 switch (error) {
2895 case -EAGAIN:
2896 if (force_blocking_asts(lkb))
2897 send_blocking_asts_all(r, lkb);
2898 break;
2899 case -EINPROGRESS:
2900 send_blocking_asts(r, lkb);
2901 break;
2902 }
2903}
2904
2905static int do_convert(struct dlm_rsb *r, struct dlm_lkb *lkb)
2906{
2907 int error = 0;
2908 int deadlk = 0;
2909
2910 /* changing an existing lock may allow others to be granted */
2911
2912 if (can_be_granted(r, lkb, 1, 0, &deadlk)) {
2913 grant_lock(r, lkb);
2914 queue_cast(r, lkb, 0);
2915 goto out;
2916 }
2917
2918 /* can_be_granted() detected that this lock would block in a conversion
2919 deadlock, so we leave it on the granted queue and return EDEADLK in
2920 the ast for the convert. */
2921
2922 if (deadlk && !(lkb->lkb_exflags & DLM_LKF_NODLCKWT)) {
2923 /* it's left on the granted queue */
2924 revert_lock(r, lkb);
2925 queue_cast(r, lkb, -EDEADLK);
2926 error = -EDEADLK;
2927 goto out;
2928 }
2929
2930 /* is_demoted() means the can_be_granted() above set the grmode
2931 to NL, and left us on the granted queue. This auto-demotion
2932 (due to CONVDEADLK) might mean other locks, and/or this lock, are
2933 now grantable. We have to try to grant other converting locks
2934 before we try again to grant this one. */
2935
2936 if (is_demoted(lkb)) {
2937 grant_pending_convert(r, DLM_LOCK_IV, NULL, NULL);
2938 if (_can_be_granted(r, lkb, 1, 0)) {
2939 grant_lock(r, lkb);
2940 queue_cast(r, lkb, 0);
2941 goto out;
2942 }
2943 /* else fall through and move to convert queue */
2944 }
2945
2946 if (can_be_queued(lkb)) {
2947 error = -EINPROGRESS;
2948 del_lkb(r, lkb);
2949 add_lkb(r, lkb, DLM_LKSTS_CONVERT);
2950 goto out;
2951 }
2952
2953 error = -EAGAIN;
2954 queue_cast(r, lkb, -EAGAIN);
2955 out:
2956 return error;
2957}
2958
2959static void do_convert_effects(struct dlm_rsb *r, struct dlm_lkb *lkb,
2960 int error)
2961{
2962 switch (error) {
2963 case 0:
2964 grant_pending_locks(r, NULL);
2965 /* grant_pending_locks also sends basts */
2966 break;
2967 case -EAGAIN:
2968 if (force_blocking_asts(lkb))
2969 send_blocking_asts_all(r, lkb);
2970 break;
2971 case -EINPROGRESS:
2972 send_blocking_asts(r, lkb);
2973 break;
2974 }
2975}
2976
2977static int do_unlock(struct dlm_rsb *r, struct dlm_lkb *lkb)
2978{
2979 remove_lock(r, lkb);
2980 queue_cast(r, lkb, -DLM_EUNLOCK);
2981 return -DLM_EUNLOCK;
2982}
2983
2984static void do_unlock_effects(struct dlm_rsb *r, struct dlm_lkb *lkb,
2985 int error)
2986{
2987 grant_pending_locks(r, NULL);
2988}
2989
2990/* returns: 0 did nothing, -DLM_ECANCEL canceled lock */
2991
2992static int do_cancel(struct dlm_rsb *r, struct dlm_lkb *lkb)
2993{
2994 int error;
2995
2996 error = revert_lock(r, lkb);
2997 if (error) {
2998 queue_cast(r, lkb, -DLM_ECANCEL);
2999 return -DLM_ECANCEL;
3000 }
3001 return 0;
3002}
3003
3004static void do_cancel_effects(struct dlm_rsb *r, struct dlm_lkb *lkb,
3005 int error)
3006{
3007 if (error)
3008 grant_pending_locks(r, NULL);
3009}
3010
3011/*
3012 * Four stage 3 varieties:
3013 * _request_lock(), _convert_lock(), _unlock_lock(), _cancel_lock()
3014 */
3015
3016/* add a new lkb to a possibly new rsb, called by requesting process */
3017
3018static int _request_lock(struct dlm_rsb *r, struct dlm_lkb *lkb)
3019{
3020 int error;
3021
3022 /* set_master: sets lkb nodeid from r */
3023
3024 error = set_master(r, lkb);
3025 if (error < 0)
3026 goto out;
3027 if (error) {
3028 error = 0;
3029 goto out;
3030 }
3031
3032 if (is_remote(r)) {
3033 /* receive_request() calls do_request() on remote node */
3034 error = send_request(r, lkb);
3035 } else {
3036 error = do_request(r, lkb);
3037 /* for remote locks the request_reply is sent
3038 between do_request and do_request_effects */
3039 do_request_effects(r, lkb, error);
3040 }
3041 out:
3042 return error;
3043}
3044
3045/* change some property of an existing lkb, e.g. mode */
3046
3047static int _convert_lock(struct dlm_rsb *r, struct dlm_lkb *lkb)
3048{
3049 int error;
3050
3051 if (is_remote(r)) {
3052 /* receive_convert() calls do_convert() on remote node */
3053 error = send_convert(r, lkb);
3054 } else {
3055 error = do_convert(r, lkb);
3056 /* for remote locks the convert_reply is sent
3057 between do_convert and do_convert_effects */
3058 do_convert_effects(r, lkb, error);
3059 }
3060
3061 return error;
3062}
3063
3064/* remove an existing lkb from the granted queue */
3065
3066static int _unlock_lock(struct dlm_rsb *r, struct dlm_lkb *lkb)
3067{
3068 int error;
3069
3070 if (is_remote(r)) {
3071 /* receive_unlock() calls do_unlock() on remote node */
3072 error = send_unlock(r, lkb);
3073 } else {
3074 error = do_unlock(r, lkb);
3075 /* for remote locks the unlock_reply is sent
3076 between do_unlock and do_unlock_effects */
3077 do_unlock_effects(r, lkb, error);
3078 }
3079
3080 return error;
3081}
3082
3083/* remove an existing lkb from the convert or wait queue */
3084
3085static int _cancel_lock(struct dlm_rsb *r, struct dlm_lkb *lkb)
3086{
3087 int error;
3088
3089 if (is_remote(r)) {
3090 /* receive_cancel() calls do_cancel() on remote node */
3091 error = send_cancel(r, lkb);
3092 } else {
3093 error = do_cancel(r, lkb);
3094 /* for remote locks the cancel_reply is sent
3095 between do_cancel and do_cancel_effects */
3096 do_cancel_effects(r, lkb, error);
3097 }
3098
3099 return error;
3100}
3101
3102/*
3103 * Four stage 2 varieties:
3104 * request_lock(), convert_lock(), unlock_lock(), cancel_lock()
3105 */
3106
3107static int request_lock(struct dlm_ls *ls, struct dlm_lkb *lkb,
3108 const void *name, int len,
3109 struct dlm_args *args)
3110{
3111 struct dlm_rsb *r;
3112 int error;
3113
3114 error = validate_lock_args(ls, lkb, args);
3115 if (error)
3116 return error;
3117
3118 error = find_rsb(ls, name, len, 0, R_REQUEST, &r);
3119 if (error)
3120 return error;
3121
3122 lock_rsb(r);
3123
3124 attach_lkb(r, lkb);
3125 lkb->lkb_lksb->sb_lkid = lkb->lkb_id;
3126
3127 error = _request_lock(r, lkb);
3128
3129 unlock_rsb(r);
3130 put_rsb(r);
3131 return error;
3132}
3133
3134static int convert_lock(struct dlm_ls *ls, struct dlm_lkb *lkb,
3135 struct dlm_args *args)
3136{
3137 struct dlm_rsb *r;
3138 int error;
3139
3140 r = lkb->lkb_resource;
3141
3142 hold_rsb(r);
3143 lock_rsb(r);
3144
3145 error = validate_lock_args(ls, lkb, args);
3146 if (error)
3147 goto out;
3148
3149 error = _convert_lock(r, lkb);
3150 out:
3151 unlock_rsb(r);
3152 put_rsb(r);
3153 return error;
3154}
3155
3156static int unlock_lock(struct dlm_ls *ls, struct dlm_lkb *lkb,
3157 struct dlm_args *args)
3158{
3159 struct dlm_rsb *r;
3160 int error;
3161
3162 r = lkb->lkb_resource;
3163
3164 hold_rsb(r);
3165 lock_rsb(r);
3166
3167 error = validate_unlock_args(lkb, args);
3168 if (error)
3169 goto out;
3170
3171 error = _unlock_lock(r, lkb);
3172 out:
3173 unlock_rsb(r);
3174 put_rsb(r);
3175 return error;
3176}
3177
3178static int cancel_lock(struct dlm_ls *ls, struct dlm_lkb *lkb,
3179 struct dlm_args *args)
3180{
3181 struct dlm_rsb *r;
3182 int error;
3183
3184 r = lkb->lkb_resource;
3185
3186 hold_rsb(r);
3187 lock_rsb(r);
3188
3189 error = validate_unlock_args(lkb, args);
3190 if (error)
3191 goto out;
3192
3193 error = _cancel_lock(r, lkb);
3194 out:
3195 unlock_rsb(r);
3196 put_rsb(r);
3197 return error;
3198}
3199
3200/*
3201 * Two stage 1 varieties: dlm_lock() and dlm_unlock()
3202 */
3203
3204int dlm_lock(dlm_lockspace_t *lockspace,
3205 int mode,
3206 struct dlm_lksb *lksb,
3207 uint32_t flags,
3208 const void *name,
3209 unsigned int namelen,
3210 uint32_t parent_lkid,
3211 void (*ast) (void *astarg),
3212 void *astarg,
3213 void (*bast) (void *astarg, int mode))
3214{
3215 struct dlm_ls *ls;
3216 struct dlm_lkb *lkb;
3217 struct dlm_args args;
3218 int error, convert = flags & DLM_LKF_CONVERT;
3219
3220 ls = dlm_find_lockspace_local(lockspace);
3221 if (!ls)
3222 return -EINVAL;
3223
3224 dlm_lock_recovery(ls);
3225
3226 if (convert)
3227 error = find_lkb(ls, lksb->sb_lkid, &lkb);
3228 else
3229 error = create_lkb(ls, &lkb);
3230
3231 if (error)
3232 goto out;
3233
3234 trace_dlm_lock_start(ls, lkb, name, namelen, mode, flags);
3235
3236 error = set_lock_args(mode, lksb, flags, namelen, ast, astarg, bast,
3237 &args);
3238 if (error)
3239 goto out_put;
3240
3241 if (convert)
3242 error = convert_lock(ls, lkb, &args);
3243 else
3244 error = request_lock(ls, lkb, name, namelen, &args);
3245
3246 if (error == -EINPROGRESS)
3247 error = 0;
3248 out_put:
3249 trace_dlm_lock_end(ls, lkb, name, namelen, mode, flags, error, true);
3250
3251 if (convert || error)
3252 __put_lkb(ls, lkb);
3253 if (error == -EAGAIN || error == -EDEADLK)
3254 error = 0;
3255 out:
3256 dlm_unlock_recovery(ls);
3257 dlm_put_lockspace(ls);
3258 return error;
3259}
3260
3261int dlm_unlock(dlm_lockspace_t *lockspace,
3262 uint32_t lkid,
3263 uint32_t flags,
3264 struct dlm_lksb *lksb,
3265 void *astarg)
3266{
3267 struct dlm_ls *ls;
3268 struct dlm_lkb *lkb;
3269 struct dlm_args args;
3270 int error;
3271
3272 ls = dlm_find_lockspace_local(lockspace);
3273 if (!ls)
3274 return -EINVAL;
3275
3276 dlm_lock_recovery(ls);
3277
3278 error = find_lkb(ls, lkid, &lkb);
3279 if (error)
3280 goto out;
3281
3282 trace_dlm_unlock_start(ls, lkb, flags);
3283
3284 error = set_unlock_args(flags, astarg, &args);
3285 if (error)
3286 goto out_put;
3287
3288 if (flags & DLM_LKF_CANCEL)
3289 error = cancel_lock(ls, lkb, &args);
3290 else
3291 error = unlock_lock(ls, lkb, &args);
3292
3293 if (error == -DLM_EUNLOCK || error == -DLM_ECANCEL)
3294 error = 0;
3295 if (error == -EBUSY && (flags & (DLM_LKF_CANCEL | DLM_LKF_FORCEUNLOCK)))
3296 error = 0;
3297 out_put:
3298 trace_dlm_unlock_end(ls, lkb, flags, error);
3299
3300 dlm_put_lkb(lkb);
3301 out:
3302 dlm_unlock_recovery(ls);
3303 dlm_put_lockspace(ls);
3304 return error;
3305}
3306
3307/*
3308 * send/receive routines for remote operations and replies
3309 *
3310 * send_args
3311 * send_common
3312 * send_request receive_request
3313 * send_convert receive_convert
3314 * send_unlock receive_unlock
3315 * send_cancel receive_cancel
3316 * send_grant receive_grant
3317 * send_bast receive_bast
3318 * send_lookup receive_lookup
3319 * send_remove receive_remove
3320 *
3321 * send_common_reply
3322 * receive_request_reply send_request_reply
3323 * receive_convert_reply send_convert_reply
3324 * receive_unlock_reply send_unlock_reply
3325 * receive_cancel_reply send_cancel_reply
3326 * receive_lookup_reply send_lookup_reply
3327 */
3328
3329static int _create_message(struct dlm_ls *ls, int mb_len,
3330 int to_nodeid, int mstype,
3331 struct dlm_message **ms_ret,
3332 struct dlm_mhandle **mh_ret,
3333 gfp_t allocation)
3334{
3335 struct dlm_message *ms;
3336 struct dlm_mhandle *mh;
3337 char *mb;
3338
3339 /* get_buffer gives us a message handle (mh) that we need to
3340 pass into midcomms_commit and a message buffer (mb) that we
3341 write our data into */
3342
3343 mh = dlm_midcomms_get_mhandle(to_nodeid, mb_len, allocation, &mb);
3344 if (!mh)
3345 return -ENOBUFS;
3346
3347 ms = (struct dlm_message *) mb;
3348
3349 ms->m_header.h_version = cpu_to_le32(DLM_HEADER_MAJOR | DLM_HEADER_MINOR);
3350 ms->m_header.u.h_lockspace = cpu_to_le32(ls->ls_global_id);
3351 ms->m_header.h_nodeid = cpu_to_le32(dlm_our_nodeid());
3352 ms->m_header.h_length = cpu_to_le16(mb_len);
3353 ms->m_header.h_cmd = DLM_MSG;
3354
3355 ms->m_type = cpu_to_le32(mstype);
3356
3357 *mh_ret = mh;
3358 *ms_ret = ms;
3359 return 0;
3360}
3361
3362static int create_message(struct dlm_rsb *r, struct dlm_lkb *lkb,
3363 int to_nodeid, int mstype,
3364 struct dlm_message **ms_ret,
3365 struct dlm_mhandle **mh_ret,
3366 gfp_t allocation)
3367{
3368 int mb_len = sizeof(struct dlm_message);
3369
3370 switch (mstype) {
3371 case DLM_MSG_REQUEST:
3372 case DLM_MSG_LOOKUP:
3373 case DLM_MSG_REMOVE:
3374 mb_len += r->res_length;
3375 break;
3376 case DLM_MSG_CONVERT:
3377 case DLM_MSG_UNLOCK:
3378 case DLM_MSG_REQUEST_REPLY:
3379 case DLM_MSG_CONVERT_REPLY:
3380 case DLM_MSG_GRANT:
3381 if (lkb && lkb->lkb_lvbptr && (lkb->lkb_exflags & DLM_LKF_VALBLK))
3382 mb_len += r->res_ls->ls_lvblen;
3383 break;
3384 }
3385
3386 return _create_message(r->res_ls, mb_len, to_nodeid, mstype,
3387 ms_ret, mh_ret, allocation);
3388}
3389
3390/* further lowcomms enhancements or alternate implementations may make
3391 the return value from this function useful at some point */
3392
3393static int send_message(struct dlm_mhandle *mh, struct dlm_message *ms,
3394 const void *name, int namelen)
3395{
3396 dlm_midcomms_commit_mhandle(mh, name, namelen);
3397 return 0;
3398}
3399
3400static void send_args(struct dlm_rsb *r, struct dlm_lkb *lkb,
3401 struct dlm_message *ms)
3402{
3403 ms->m_nodeid = cpu_to_le32(lkb->lkb_nodeid);
3404 ms->m_pid = cpu_to_le32(lkb->lkb_ownpid);
3405 ms->m_lkid = cpu_to_le32(lkb->lkb_id);
3406 ms->m_remid = cpu_to_le32(lkb->lkb_remid);
3407 ms->m_exflags = cpu_to_le32(lkb->lkb_exflags);
3408 ms->m_sbflags = cpu_to_le32(dlm_sbflags_val(lkb));
3409 ms->m_flags = cpu_to_le32(dlm_dflags_val(lkb));
3410 ms->m_lvbseq = cpu_to_le32(lkb->lkb_lvbseq);
3411 ms->m_status = cpu_to_le32(lkb->lkb_status);
3412 ms->m_grmode = cpu_to_le32(lkb->lkb_grmode);
3413 ms->m_rqmode = cpu_to_le32(lkb->lkb_rqmode);
3414 ms->m_hash = cpu_to_le32(r->res_hash);
3415
3416 /* m_result and m_bastmode are set from function args,
3417 not from lkb fields */
3418
3419 if (lkb->lkb_bastfn)
3420 ms->m_asts |= cpu_to_le32(DLM_CB_BAST);
3421 if (lkb->lkb_astfn)
3422 ms->m_asts |= cpu_to_le32(DLM_CB_CAST);
3423
3424 /* compare with switch in create_message; send_remove() doesn't
3425 use send_args() */
3426
3427 switch (ms->m_type) {
3428 case cpu_to_le32(DLM_MSG_REQUEST):
3429 case cpu_to_le32(DLM_MSG_LOOKUP):
3430 memcpy(ms->m_extra, r->res_name, r->res_length);
3431 break;
3432 case cpu_to_le32(DLM_MSG_CONVERT):
3433 case cpu_to_le32(DLM_MSG_UNLOCK):
3434 case cpu_to_le32(DLM_MSG_REQUEST_REPLY):
3435 case cpu_to_le32(DLM_MSG_CONVERT_REPLY):
3436 case cpu_to_le32(DLM_MSG_GRANT):
3437 if (!lkb->lkb_lvbptr || !(lkb->lkb_exflags & DLM_LKF_VALBLK))
3438 break;
3439 memcpy(ms->m_extra, lkb->lkb_lvbptr, r->res_ls->ls_lvblen);
3440 break;
3441 }
3442}
3443
3444static int send_common(struct dlm_rsb *r, struct dlm_lkb *lkb, int mstype)
3445{
3446 struct dlm_message *ms;
3447 struct dlm_mhandle *mh;
3448 int to_nodeid, error;
3449
3450 to_nodeid = r->res_nodeid;
3451
3452 error = add_to_waiters(lkb, mstype, to_nodeid);
3453 if (error)
3454 return error;
3455
3456 error = create_message(r, lkb, to_nodeid, mstype, &ms, &mh, GFP_NOFS);
3457 if (error)
3458 goto fail;
3459
3460 send_args(r, lkb, ms);
3461
3462 error = send_message(mh, ms, r->res_name, r->res_length);
3463 if (error)
3464 goto fail;
3465 return 0;
3466
3467 fail:
3468 remove_from_waiters(lkb, msg_reply_type(mstype));
3469 return error;
3470}
3471
3472static int send_request(struct dlm_rsb *r, struct dlm_lkb *lkb)
3473{
3474 return send_common(r, lkb, DLM_MSG_REQUEST);
3475}
3476
3477static int send_convert(struct dlm_rsb *r, struct dlm_lkb *lkb)
3478{
3479 int error;
3480
3481 error = send_common(r, lkb, DLM_MSG_CONVERT);
3482
3483 /* down conversions go without a reply from the master */
3484 if (!error && down_conversion(lkb)) {
3485 remove_from_waiters(lkb, DLM_MSG_CONVERT_REPLY);
3486 r->res_ls->ls_local_ms.m_type = cpu_to_le32(DLM_MSG_CONVERT_REPLY);
3487 r->res_ls->ls_local_ms.m_result = 0;
3488 __receive_convert_reply(r, lkb, &r->res_ls->ls_local_ms, true);
3489 }
3490
3491 return error;
3492}
3493
3494/* FIXME: if this lkb is the only lock we hold on the rsb, then set
3495 MASTER_UNCERTAIN to force the next request on the rsb to confirm
3496 that the master is still correct. */
3497
3498static int send_unlock(struct dlm_rsb *r, struct dlm_lkb *lkb)
3499{
3500 return send_common(r, lkb, DLM_MSG_UNLOCK);
3501}
3502
3503static int send_cancel(struct dlm_rsb *r, struct dlm_lkb *lkb)
3504{
3505 return send_common(r, lkb, DLM_MSG_CANCEL);
3506}
3507
3508static int send_grant(struct dlm_rsb *r, struct dlm_lkb *lkb)
3509{
3510 struct dlm_message *ms;
3511 struct dlm_mhandle *mh;
3512 int to_nodeid, error;
3513
3514 to_nodeid = lkb->lkb_nodeid;
3515
3516 error = create_message(r, lkb, to_nodeid, DLM_MSG_GRANT, &ms, &mh,
3517 GFP_NOFS);
3518 if (error)
3519 goto out;
3520
3521 send_args(r, lkb, ms);
3522
3523 ms->m_result = 0;
3524
3525 error = send_message(mh, ms, r->res_name, r->res_length);
3526 out:
3527 return error;
3528}
3529
3530static int send_bast(struct dlm_rsb *r, struct dlm_lkb *lkb, int mode)
3531{
3532 struct dlm_message *ms;
3533 struct dlm_mhandle *mh;
3534 int to_nodeid, error;
3535
3536 to_nodeid = lkb->lkb_nodeid;
3537
3538 error = create_message(r, NULL, to_nodeid, DLM_MSG_BAST, &ms, &mh,
3539 GFP_NOFS);
3540 if (error)
3541 goto out;
3542
3543 send_args(r, lkb, ms);
3544
3545 ms->m_bastmode = cpu_to_le32(mode);
3546
3547 error = send_message(mh, ms, r->res_name, r->res_length);
3548 out:
3549 return error;
3550}
3551
3552static int send_lookup(struct dlm_rsb *r, struct dlm_lkb *lkb)
3553{
3554 struct dlm_message *ms;
3555 struct dlm_mhandle *mh;
3556 int to_nodeid, error;
3557
3558 to_nodeid = dlm_dir_nodeid(r);
3559
3560 error = add_to_waiters(lkb, DLM_MSG_LOOKUP, to_nodeid);
3561 if (error)
3562 return error;
3563
3564 error = create_message(r, NULL, to_nodeid, DLM_MSG_LOOKUP, &ms, &mh,
3565 GFP_NOFS);
3566 if (error)
3567 goto fail;
3568
3569 send_args(r, lkb, ms);
3570
3571 error = send_message(mh, ms, r->res_name, r->res_length);
3572 if (error)
3573 goto fail;
3574 return 0;
3575
3576 fail:
3577 remove_from_waiters(lkb, DLM_MSG_LOOKUP_REPLY);
3578 return error;
3579}
3580
3581static int send_remove(struct dlm_rsb *r)
3582{
3583 struct dlm_message *ms;
3584 struct dlm_mhandle *mh;
3585 int to_nodeid, error;
3586
3587 to_nodeid = dlm_dir_nodeid(r);
3588
3589 error = create_message(r, NULL, to_nodeid, DLM_MSG_REMOVE, &ms, &mh,
3590 GFP_ATOMIC);
3591 if (error)
3592 goto out;
3593
3594 memcpy(ms->m_extra, r->res_name, r->res_length);
3595 ms->m_hash = cpu_to_le32(r->res_hash);
3596
3597 error = send_message(mh, ms, r->res_name, r->res_length);
3598 out:
3599 return error;
3600}
3601
3602static int send_common_reply(struct dlm_rsb *r, struct dlm_lkb *lkb,
3603 int mstype, int rv)
3604{
3605 struct dlm_message *ms;
3606 struct dlm_mhandle *mh;
3607 int to_nodeid, error;
3608
3609 to_nodeid = lkb->lkb_nodeid;
3610
3611 error = create_message(r, lkb, to_nodeid, mstype, &ms, &mh, GFP_NOFS);
3612 if (error)
3613 goto out;
3614
3615 send_args(r, lkb, ms);
3616
3617 ms->m_result = cpu_to_le32(to_dlm_errno(rv));
3618
3619 error = send_message(mh, ms, r->res_name, r->res_length);
3620 out:
3621 return error;
3622}
3623
3624static int send_request_reply(struct dlm_rsb *r, struct dlm_lkb *lkb, int rv)
3625{
3626 return send_common_reply(r, lkb, DLM_MSG_REQUEST_REPLY, rv);
3627}
3628
3629static int send_convert_reply(struct dlm_rsb *r, struct dlm_lkb *lkb, int rv)
3630{
3631 return send_common_reply(r, lkb, DLM_MSG_CONVERT_REPLY, rv);
3632}
3633
3634static int send_unlock_reply(struct dlm_rsb *r, struct dlm_lkb *lkb, int rv)
3635{
3636 return send_common_reply(r, lkb, DLM_MSG_UNLOCK_REPLY, rv);
3637}
3638
3639static int send_cancel_reply(struct dlm_rsb *r, struct dlm_lkb *lkb, int rv)
3640{
3641 return send_common_reply(r, lkb, DLM_MSG_CANCEL_REPLY, rv);
3642}
3643
3644static int send_lookup_reply(struct dlm_ls *ls,
3645 const struct dlm_message *ms_in, int ret_nodeid,
3646 int rv)
3647{
3648 struct dlm_rsb *r = &ls->ls_local_rsb;
3649 struct dlm_message *ms;
3650 struct dlm_mhandle *mh;
3651 int error, nodeid = le32_to_cpu(ms_in->m_header.h_nodeid);
3652
3653 error = create_message(r, NULL, nodeid, DLM_MSG_LOOKUP_REPLY, &ms, &mh,
3654 GFP_NOFS);
3655 if (error)
3656 goto out;
3657
3658 ms->m_lkid = ms_in->m_lkid;
3659 ms->m_result = cpu_to_le32(to_dlm_errno(rv));
3660 ms->m_nodeid = cpu_to_le32(ret_nodeid);
3661
3662 error = send_message(mh, ms, ms_in->m_extra, receive_extralen(ms_in));
3663 out:
3664 return error;
3665}
3666
3667/* which args we save from a received message depends heavily on the type
3668 of message, unlike the send side where we can safely send everything about
3669 the lkb for any type of message */
3670
3671static void receive_flags(struct dlm_lkb *lkb, const struct dlm_message *ms)
3672{
3673 lkb->lkb_exflags = le32_to_cpu(ms->m_exflags);
3674 dlm_set_sbflags_val(lkb, le32_to_cpu(ms->m_sbflags));
3675 dlm_set_dflags_val(lkb, le32_to_cpu(ms->m_flags));
3676}
3677
3678static void receive_flags_reply(struct dlm_lkb *lkb,
3679 const struct dlm_message *ms,
3680 bool local)
3681{
3682 if (local)
3683 return;
3684
3685 dlm_set_sbflags_val(lkb, le32_to_cpu(ms->m_sbflags));
3686 dlm_set_dflags_val(lkb, le32_to_cpu(ms->m_flags));
3687}
3688
3689static int receive_extralen(const struct dlm_message *ms)
3690{
3691 return (le16_to_cpu(ms->m_header.h_length) -
3692 sizeof(struct dlm_message));
3693}
3694
3695static int receive_lvb(struct dlm_ls *ls, struct dlm_lkb *lkb,
3696 const struct dlm_message *ms)
3697{
3698 int len;
3699
3700 if (lkb->lkb_exflags & DLM_LKF_VALBLK) {
3701 if (!lkb->lkb_lvbptr)
3702 lkb->lkb_lvbptr = dlm_allocate_lvb(ls);
3703 if (!lkb->lkb_lvbptr)
3704 return -ENOMEM;
3705 len = receive_extralen(ms);
3706 if (len > ls->ls_lvblen)
3707 len = ls->ls_lvblen;
3708 memcpy(lkb->lkb_lvbptr, ms->m_extra, len);
3709 }
3710 return 0;
3711}
3712
3713static void fake_bastfn(void *astparam, int mode)
3714{
3715 log_print("fake_bastfn should not be called");
3716}
3717
3718static void fake_astfn(void *astparam)
3719{
3720 log_print("fake_astfn should not be called");
3721}
3722
3723static int receive_request_args(struct dlm_ls *ls, struct dlm_lkb *lkb,
3724 const struct dlm_message *ms)
3725{
3726 lkb->lkb_nodeid = le32_to_cpu(ms->m_header.h_nodeid);
3727 lkb->lkb_ownpid = le32_to_cpu(ms->m_pid);
3728 lkb->lkb_remid = le32_to_cpu(ms->m_lkid);
3729 lkb->lkb_grmode = DLM_LOCK_IV;
3730 lkb->lkb_rqmode = le32_to_cpu(ms->m_rqmode);
3731
3732 lkb->lkb_bastfn = (ms->m_asts & cpu_to_le32(DLM_CB_BAST)) ? &fake_bastfn : NULL;
3733 lkb->lkb_astfn = (ms->m_asts & cpu_to_le32(DLM_CB_CAST)) ? &fake_astfn : NULL;
3734
3735 if (lkb->lkb_exflags & DLM_LKF_VALBLK) {
3736 /* lkb was just created so there won't be an lvb yet */
3737 lkb->lkb_lvbptr = dlm_allocate_lvb(ls);
3738 if (!lkb->lkb_lvbptr)
3739 return -ENOMEM;
3740 }
3741
3742 return 0;
3743}
3744
3745static int receive_convert_args(struct dlm_ls *ls, struct dlm_lkb *lkb,
3746 const struct dlm_message *ms)
3747{
3748 if (lkb->lkb_status != DLM_LKSTS_GRANTED)
3749 return -EBUSY;
3750
3751 if (receive_lvb(ls, lkb, ms))
3752 return -ENOMEM;
3753
3754 lkb->lkb_rqmode = le32_to_cpu(ms->m_rqmode);
3755 lkb->lkb_lvbseq = le32_to_cpu(ms->m_lvbseq);
3756
3757 return 0;
3758}
3759
3760static int receive_unlock_args(struct dlm_ls *ls, struct dlm_lkb *lkb,
3761 const struct dlm_message *ms)
3762{
3763 if (receive_lvb(ls, lkb, ms))
3764 return -ENOMEM;
3765 return 0;
3766}
3767
3768/* We fill in the local-lkb fields with the info that send_xxxx_reply()
3769 uses to send a reply and that the remote end uses to process the reply. */
3770
3771static void setup_local_lkb(struct dlm_ls *ls, const struct dlm_message *ms)
3772{
3773 struct dlm_lkb *lkb = &ls->ls_local_lkb;
3774 lkb->lkb_nodeid = le32_to_cpu(ms->m_header.h_nodeid);
3775 lkb->lkb_remid = le32_to_cpu(ms->m_lkid);
3776}
3777
3778/* This is called after the rsb is locked so that we can safely inspect
3779 fields in the lkb. */
3780
3781static int validate_message(struct dlm_lkb *lkb, const struct dlm_message *ms)
3782{
3783 int from = le32_to_cpu(ms->m_header.h_nodeid);
3784 int error = 0;
3785
3786 /* currently mixing of user/kernel locks are not supported */
3787 if (ms->m_flags & cpu_to_le32(BIT(DLM_DFL_USER_BIT)) &&
3788 !test_bit(DLM_DFL_USER_BIT, &lkb->lkb_dflags)) {
3789 log_error(lkb->lkb_resource->res_ls,
3790 "got user dlm message for a kernel lock");
3791 error = -EINVAL;
3792 goto out;
3793 }
3794
3795 switch (ms->m_type) {
3796 case cpu_to_le32(DLM_MSG_CONVERT):
3797 case cpu_to_le32(DLM_MSG_UNLOCK):
3798 case cpu_to_le32(DLM_MSG_CANCEL):
3799 if (!is_master_copy(lkb) || lkb->lkb_nodeid != from)
3800 error = -EINVAL;
3801 break;
3802
3803 case cpu_to_le32(DLM_MSG_CONVERT_REPLY):
3804 case cpu_to_le32(DLM_MSG_UNLOCK_REPLY):
3805 case cpu_to_le32(DLM_MSG_CANCEL_REPLY):
3806 case cpu_to_le32(DLM_MSG_GRANT):
3807 case cpu_to_le32(DLM_MSG_BAST):
3808 if (!is_process_copy(lkb) || lkb->lkb_nodeid != from)
3809 error = -EINVAL;
3810 break;
3811
3812 case cpu_to_le32(DLM_MSG_REQUEST_REPLY):
3813 if (!is_process_copy(lkb))
3814 error = -EINVAL;
3815 else if (lkb->lkb_nodeid != -1 && lkb->lkb_nodeid != from)
3816 error = -EINVAL;
3817 break;
3818
3819 default:
3820 error = -EINVAL;
3821 }
3822
3823out:
3824 if (error)
3825 log_error(lkb->lkb_resource->res_ls,
3826 "ignore invalid message %d from %d %x %x %x %d",
3827 le32_to_cpu(ms->m_type), from, lkb->lkb_id,
3828 lkb->lkb_remid, dlm_iflags_val(lkb),
3829 lkb->lkb_nodeid);
3830 return error;
3831}
3832
3833static int receive_request(struct dlm_ls *ls, const struct dlm_message *ms)
3834{
3835 struct dlm_lkb *lkb;
3836 struct dlm_rsb *r;
3837 int from_nodeid;
3838 int error, namelen = 0;
3839
3840 from_nodeid = le32_to_cpu(ms->m_header.h_nodeid);
3841
3842 error = create_lkb(ls, &lkb);
3843 if (error)
3844 goto fail;
3845
3846 receive_flags(lkb, ms);
3847 set_bit(DLM_IFL_MSTCPY_BIT, &lkb->lkb_iflags);
3848 error = receive_request_args(ls, lkb, ms);
3849 if (error) {
3850 __put_lkb(ls, lkb);
3851 goto fail;
3852 }
3853
3854 /* The dir node is the authority on whether we are the master
3855 for this rsb or not, so if the master sends us a request, we should
3856 recreate the rsb if we've destroyed it. This race happens when we
3857 send a remove message to the dir node at the same time that the dir
3858 node sends us a request for the rsb. */
3859
3860 namelen = receive_extralen(ms);
3861
3862 error = find_rsb(ls, ms->m_extra, namelen, from_nodeid,
3863 R_RECEIVE_REQUEST, &r);
3864 if (error) {
3865 __put_lkb(ls, lkb);
3866 goto fail;
3867 }
3868
3869 lock_rsb(r);
3870
3871 if (r->res_master_nodeid != dlm_our_nodeid()) {
3872 error = validate_master_nodeid(ls, r, from_nodeid);
3873 if (error) {
3874 unlock_rsb(r);
3875 put_rsb(r);
3876 __put_lkb(ls, lkb);
3877 goto fail;
3878 }
3879 }
3880
3881 attach_lkb(r, lkb);
3882 error = do_request(r, lkb);
3883 send_request_reply(r, lkb, error);
3884 do_request_effects(r, lkb, error);
3885
3886 unlock_rsb(r);
3887 put_rsb(r);
3888
3889 if (error == -EINPROGRESS)
3890 error = 0;
3891 if (error)
3892 dlm_put_lkb(lkb);
3893 return 0;
3894
3895 fail:
3896 /* TODO: instead of returning ENOTBLK, add the lkb to res_lookup
3897 and do this receive_request again from process_lookup_list once
3898 we get the lookup reply. This would avoid a many repeated
3899 ENOTBLK request failures when the lookup reply designating us
3900 as master is delayed. */
3901
3902 if (error != -ENOTBLK) {
3903 log_limit(ls, "receive_request %x from %d %d",
3904 le32_to_cpu(ms->m_lkid), from_nodeid, error);
3905 }
3906
3907 setup_local_lkb(ls, ms);
3908 send_request_reply(&ls->ls_local_rsb, &ls->ls_local_lkb, error);
3909 return error;
3910}
3911
3912static int receive_convert(struct dlm_ls *ls, const struct dlm_message *ms)
3913{
3914 struct dlm_lkb *lkb;
3915 struct dlm_rsb *r;
3916 int error, reply = 1;
3917
3918 error = find_lkb(ls, le32_to_cpu(ms->m_remid), &lkb);
3919 if (error)
3920 goto fail;
3921
3922 if (lkb->lkb_remid != le32_to_cpu(ms->m_lkid)) {
3923 log_error(ls, "receive_convert %x remid %x recover_seq %llu "
3924 "remote %d %x", lkb->lkb_id, lkb->lkb_remid,
3925 (unsigned long long)lkb->lkb_recover_seq,
3926 le32_to_cpu(ms->m_header.h_nodeid),
3927 le32_to_cpu(ms->m_lkid));
3928 error = -ENOENT;
3929 dlm_put_lkb(lkb);
3930 goto fail;
3931 }
3932
3933 r = lkb->lkb_resource;
3934
3935 hold_rsb(r);
3936 lock_rsb(r);
3937
3938 error = validate_message(lkb, ms);
3939 if (error)
3940 goto out;
3941
3942 receive_flags(lkb, ms);
3943
3944 error = receive_convert_args(ls, lkb, ms);
3945 if (error) {
3946 send_convert_reply(r, lkb, error);
3947 goto out;
3948 }
3949
3950 reply = !down_conversion(lkb);
3951
3952 error = do_convert(r, lkb);
3953 if (reply)
3954 send_convert_reply(r, lkb, error);
3955 do_convert_effects(r, lkb, error);
3956 out:
3957 unlock_rsb(r);
3958 put_rsb(r);
3959 dlm_put_lkb(lkb);
3960 return 0;
3961
3962 fail:
3963 setup_local_lkb(ls, ms);
3964 send_convert_reply(&ls->ls_local_rsb, &ls->ls_local_lkb, error);
3965 return error;
3966}
3967
3968static int receive_unlock(struct dlm_ls *ls, const struct dlm_message *ms)
3969{
3970 struct dlm_lkb *lkb;
3971 struct dlm_rsb *r;
3972 int error;
3973
3974 error = find_lkb(ls, le32_to_cpu(ms->m_remid), &lkb);
3975 if (error)
3976 goto fail;
3977
3978 if (lkb->lkb_remid != le32_to_cpu(ms->m_lkid)) {
3979 log_error(ls, "receive_unlock %x remid %x remote %d %x",
3980 lkb->lkb_id, lkb->lkb_remid,
3981 le32_to_cpu(ms->m_header.h_nodeid),
3982 le32_to_cpu(ms->m_lkid));
3983 error = -ENOENT;
3984 dlm_put_lkb(lkb);
3985 goto fail;
3986 }
3987
3988 r = lkb->lkb_resource;
3989
3990 hold_rsb(r);
3991 lock_rsb(r);
3992
3993 error = validate_message(lkb, ms);
3994 if (error)
3995 goto out;
3996
3997 receive_flags(lkb, ms);
3998
3999 error = receive_unlock_args(ls, lkb, ms);
4000 if (error) {
4001 send_unlock_reply(r, lkb, error);
4002 goto out;
4003 }
4004
4005 error = do_unlock(r, lkb);
4006 send_unlock_reply(r, lkb, error);
4007 do_unlock_effects(r, lkb, error);
4008 out:
4009 unlock_rsb(r);
4010 put_rsb(r);
4011 dlm_put_lkb(lkb);
4012 return 0;
4013
4014 fail:
4015 setup_local_lkb(ls, ms);
4016 send_unlock_reply(&ls->ls_local_rsb, &ls->ls_local_lkb, error);
4017 return error;
4018}
4019
4020static int receive_cancel(struct dlm_ls *ls, const struct dlm_message *ms)
4021{
4022 struct dlm_lkb *lkb;
4023 struct dlm_rsb *r;
4024 int error;
4025
4026 error = find_lkb(ls, le32_to_cpu(ms->m_remid), &lkb);
4027 if (error)
4028 goto fail;
4029
4030 receive_flags(lkb, ms);
4031
4032 r = lkb->lkb_resource;
4033
4034 hold_rsb(r);
4035 lock_rsb(r);
4036
4037 error = validate_message(lkb, ms);
4038 if (error)
4039 goto out;
4040
4041 error = do_cancel(r, lkb);
4042 send_cancel_reply(r, lkb, error);
4043 do_cancel_effects(r, lkb, error);
4044 out:
4045 unlock_rsb(r);
4046 put_rsb(r);
4047 dlm_put_lkb(lkb);
4048 return 0;
4049
4050 fail:
4051 setup_local_lkb(ls, ms);
4052 send_cancel_reply(&ls->ls_local_rsb, &ls->ls_local_lkb, error);
4053 return error;
4054}
4055
4056static int receive_grant(struct dlm_ls *ls, const struct dlm_message *ms)
4057{
4058 struct dlm_lkb *lkb;
4059 struct dlm_rsb *r;
4060 int error;
4061
4062 error = find_lkb(ls, le32_to_cpu(ms->m_remid), &lkb);
4063 if (error)
4064 return error;
4065
4066 r = lkb->lkb_resource;
4067
4068 hold_rsb(r);
4069 lock_rsb(r);
4070
4071 error = validate_message(lkb, ms);
4072 if (error)
4073 goto out;
4074
4075 receive_flags_reply(lkb, ms, false);
4076 if (is_altmode(lkb))
4077 munge_altmode(lkb, ms);
4078 grant_lock_pc(r, lkb, ms);
4079 queue_cast(r, lkb, 0);
4080 out:
4081 unlock_rsb(r);
4082 put_rsb(r);
4083 dlm_put_lkb(lkb);
4084 return 0;
4085}
4086
4087static int receive_bast(struct dlm_ls *ls, const struct dlm_message *ms)
4088{
4089 struct dlm_lkb *lkb;
4090 struct dlm_rsb *r;
4091 int error;
4092
4093 error = find_lkb(ls, le32_to_cpu(ms->m_remid), &lkb);
4094 if (error)
4095 return error;
4096
4097 r = lkb->lkb_resource;
4098
4099 hold_rsb(r);
4100 lock_rsb(r);
4101
4102 error = validate_message(lkb, ms);
4103 if (error)
4104 goto out;
4105
4106 queue_bast(r, lkb, le32_to_cpu(ms->m_bastmode));
4107 lkb->lkb_highbast = le32_to_cpu(ms->m_bastmode);
4108 out:
4109 unlock_rsb(r);
4110 put_rsb(r);
4111 dlm_put_lkb(lkb);
4112 return 0;
4113}
4114
4115static void receive_lookup(struct dlm_ls *ls, const struct dlm_message *ms)
4116{
4117 int len, error, ret_nodeid, from_nodeid, our_nodeid;
4118
4119 from_nodeid = le32_to_cpu(ms->m_header.h_nodeid);
4120 our_nodeid = dlm_our_nodeid();
4121
4122 len = receive_extralen(ms);
4123
4124 error = dlm_master_lookup(ls, from_nodeid, ms->m_extra, len, 0,
4125 &ret_nodeid, NULL);
4126
4127 /* Optimization: we're master so treat lookup as a request */
4128 if (!error && ret_nodeid == our_nodeid) {
4129 receive_request(ls, ms);
4130 return;
4131 }
4132 send_lookup_reply(ls, ms, ret_nodeid, error);
4133}
4134
4135static void receive_remove(struct dlm_ls *ls, const struct dlm_message *ms)
4136{
4137 char name[DLM_RESNAME_MAXLEN+1];
4138 struct dlm_rsb *r;
4139 uint32_t hash, b;
4140 int rv, len, dir_nodeid, from_nodeid;
4141
4142 from_nodeid = le32_to_cpu(ms->m_header.h_nodeid);
4143
4144 len = receive_extralen(ms);
4145
4146 if (len > DLM_RESNAME_MAXLEN) {
4147 log_error(ls, "receive_remove from %d bad len %d",
4148 from_nodeid, len);
4149 return;
4150 }
4151
4152 dir_nodeid = dlm_hash2nodeid(ls, le32_to_cpu(ms->m_hash));
4153 if (dir_nodeid != dlm_our_nodeid()) {
4154 log_error(ls, "receive_remove from %d bad nodeid %d",
4155 from_nodeid, dir_nodeid);
4156 return;
4157 }
4158
4159 /* Look for name on rsbtbl.toss, if it's there, kill it.
4160 If it's on rsbtbl.keep, it's being used, and we should ignore this
4161 message. This is an expected race between the dir node sending a
4162 request to the master node at the same time as the master node sends
4163 a remove to the dir node. The resolution to that race is for the
4164 dir node to ignore the remove message, and the master node to
4165 recreate the master rsb when it gets a request from the dir node for
4166 an rsb it doesn't have. */
4167
4168 memset(name, 0, sizeof(name));
4169 memcpy(name, ms->m_extra, len);
4170
4171 hash = jhash(name, len, 0);
4172 b = hash & (ls->ls_rsbtbl_size - 1);
4173
4174 spin_lock(&ls->ls_rsbtbl[b].lock);
4175
4176 rv = dlm_search_rsb_tree(&ls->ls_rsbtbl[b].toss, name, len, &r);
4177 if (rv) {
4178 /* verify the rsb is on keep list per comment above */
4179 rv = dlm_search_rsb_tree(&ls->ls_rsbtbl[b].keep, name, len, &r);
4180 if (rv) {
4181 /* should not happen */
4182 log_error(ls, "receive_remove from %d not found %s",
4183 from_nodeid, name);
4184 spin_unlock(&ls->ls_rsbtbl[b].lock);
4185 return;
4186 }
4187 if (r->res_master_nodeid != from_nodeid) {
4188 /* should not happen */
4189 log_error(ls, "receive_remove keep from %d master %d",
4190 from_nodeid, r->res_master_nodeid);
4191 dlm_print_rsb(r);
4192 spin_unlock(&ls->ls_rsbtbl[b].lock);
4193 return;
4194 }
4195
4196 log_debug(ls, "receive_remove from %d master %d first %x %s",
4197 from_nodeid, r->res_master_nodeid, r->res_first_lkid,
4198 name);
4199 spin_unlock(&ls->ls_rsbtbl[b].lock);
4200 return;
4201 }
4202
4203 if (r->res_master_nodeid != from_nodeid) {
4204 log_error(ls, "receive_remove toss from %d master %d",
4205 from_nodeid, r->res_master_nodeid);
4206 dlm_print_rsb(r);
4207 spin_unlock(&ls->ls_rsbtbl[b].lock);
4208 return;
4209 }
4210
4211 if (kref_put(&r->res_ref, kill_rsb)) {
4212 rb_erase(&r->res_hashnode, &ls->ls_rsbtbl[b].toss);
4213 spin_unlock(&ls->ls_rsbtbl[b].lock);
4214 dlm_free_rsb(r);
4215 } else {
4216 log_error(ls, "receive_remove from %d rsb ref error",
4217 from_nodeid);
4218 dlm_print_rsb(r);
4219 spin_unlock(&ls->ls_rsbtbl[b].lock);
4220 }
4221}
4222
4223static void receive_purge(struct dlm_ls *ls, const struct dlm_message *ms)
4224{
4225 do_purge(ls, le32_to_cpu(ms->m_nodeid), le32_to_cpu(ms->m_pid));
4226}
4227
4228static int receive_request_reply(struct dlm_ls *ls,
4229 const struct dlm_message *ms)
4230{
4231 struct dlm_lkb *lkb;
4232 struct dlm_rsb *r;
4233 int error, mstype, result;
4234 int from_nodeid = le32_to_cpu(ms->m_header.h_nodeid);
4235
4236 error = find_lkb(ls, le32_to_cpu(ms->m_remid), &lkb);
4237 if (error)
4238 return error;
4239
4240 r = lkb->lkb_resource;
4241 hold_rsb(r);
4242 lock_rsb(r);
4243
4244 error = validate_message(lkb, ms);
4245 if (error)
4246 goto out;
4247
4248 mstype = lkb->lkb_wait_type;
4249 error = remove_from_waiters(lkb, DLM_MSG_REQUEST_REPLY);
4250 if (error) {
4251 log_error(ls, "receive_request_reply %x remote %d %x result %d",
4252 lkb->lkb_id, from_nodeid, le32_to_cpu(ms->m_lkid),
4253 from_dlm_errno(le32_to_cpu(ms->m_result)));
4254 dlm_dump_rsb(r);
4255 goto out;
4256 }
4257
4258 /* Optimization: the dir node was also the master, so it took our
4259 lookup as a request and sent request reply instead of lookup reply */
4260 if (mstype == DLM_MSG_LOOKUP) {
4261 r->res_master_nodeid = from_nodeid;
4262 r->res_nodeid = from_nodeid;
4263 lkb->lkb_nodeid = from_nodeid;
4264 }
4265
4266 /* this is the value returned from do_request() on the master */
4267 result = from_dlm_errno(le32_to_cpu(ms->m_result));
4268
4269 switch (result) {
4270 case -EAGAIN:
4271 /* request would block (be queued) on remote master */
4272 queue_cast(r, lkb, -EAGAIN);
4273 confirm_master(r, -EAGAIN);
4274 unhold_lkb(lkb); /* undoes create_lkb() */
4275 break;
4276
4277 case -EINPROGRESS:
4278 case 0:
4279 /* request was queued or granted on remote master */
4280 receive_flags_reply(lkb, ms, false);
4281 lkb->lkb_remid = le32_to_cpu(ms->m_lkid);
4282 if (is_altmode(lkb))
4283 munge_altmode(lkb, ms);
4284 if (result) {
4285 add_lkb(r, lkb, DLM_LKSTS_WAITING);
4286 } else {
4287 grant_lock_pc(r, lkb, ms);
4288 queue_cast(r, lkb, 0);
4289 }
4290 confirm_master(r, result);
4291 break;
4292
4293 case -EBADR:
4294 case -ENOTBLK:
4295 /* find_rsb failed to find rsb or rsb wasn't master */
4296 log_limit(ls, "receive_request_reply %x from %d %d "
4297 "master %d dir %d first %x %s", lkb->lkb_id,
4298 from_nodeid, result, r->res_master_nodeid,
4299 r->res_dir_nodeid, r->res_first_lkid, r->res_name);
4300
4301 if (r->res_dir_nodeid != dlm_our_nodeid() &&
4302 r->res_master_nodeid != dlm_our_nodeid()) {
4303 /* cause _request_lock->set_master->send_lookup */
4304 r->res_master_nodeid = 0;
4305 r->res_nodeid = -1;
4306 lkb->lkb_nodeid = -1;
4307 }
4308
4309 if (is_overlap(lkb)) {
4310 /* we'll ignore error in cancel/unlock reply */
4311 queue_cast_overlap(r, lkb);
4312 confirm_master(r, result);
4313 unhold_lkb(lkb); /* undoes create_lkb() */
4314 } else {
4315 _request_lock(r, lkb);
4316
4317 if (r->res_master_nodeid == dlm_our_nodeid())
4318 confirm_master(r, 0);
4319 }
4320 break;
4321
4322 default:
4323 log_error(ls, "receive_request_reply %x error %d",
4324 lkb->lkb_id, result);
4325 }
4326
4327 if ((result == 0 || result == -EINPROGRESS) &&
4328 test_and_clear_bit(DLM_IFL_OVERLAP_UNLOCK_BIT, &lkb->lkb_iflags)) {
4329 log_debug(ls, "receive_request_reply %x result %d unlock",
4330 lkb->lkb_id, result);
4331 clear_bit(DLM_IFL_OVERLAP_CANCEL_BIT, &lkb->lkb_iflags);
4332 send_unlock(r, lkb);
4333 } else if ((result == -EINPROGRESS) &&
4334 test_and_clear_bit(DLM_IFL_OVERLAP_CANCEL_BIT,
4335 &lkb->lkb_iflags)) {
4336 log_debug(ls, "receive_request_reply %x cancel", lkb->lkb_id);
4337 clear_bit(DLM_IFL_OVERLAP_UNLOCK_BIT, &lkb->lkb_iflags);
4338 send_cancel(r, lkb);
4339 } else {
4340 clear_bit(DLM_IFL_OVERLAP_CANCEL_BIT, &lkb->lkb_iflags);
4341 clear_bit(DLM_IFL_OVERLAP_UNLOCK_BIT, &lkb->lkb_iflags);
4342 }
4343 out:
4344 unlock_rsb(r);
4345 put_rsb(r);
4346 dlm_put_lkb(lkb);
4347 return 0;
4348}
4349
4350static void __receive_convert_reply(struct dlm_rsb *r, struct dlm_lkb *lkb,
4351 const struct dlm_message *ms, bool local)
4352{
4353 /* this is the value returned from do_convert() on the master */
4354 switch (from_dlm_errno(le32_to_cpu(ms->m_result))) {
4355 case -EAGAIN:
4356 /* convert would block (be queued) on remote master */
4357 queue_cast(r, lkb, -EAGAIN);
4358 break;
4359
4360 case -EDEADLK:
4361 receive_flags_reply(lkb, ms, local);
4362 revert_lock_pc(r, lkb);
4363 queue_cast(r, lkb, -EDEADLK);
4364 break;
4365
4366 case -EINPROGRESS:
4367 /* convert was queued on remote master */
4368 receive_flags_reply(lkb, ms, local);
4369 if (is_demoted(lkb))
4370 munge_demoted(lkb);
4371 del_lkb(r, lkb);
4372 add_lkb(r, lkb, DLM_LKSTS_CONVERT);
4373 break;
4374
4375 case 0:
4376 /* convert was granted on remote master */
4377 receive_flags_reply(lkb, ms, local);
4378 if (is_demoted(lkb))
4379 munge_demoted(lkb);
4380 grant_lock_pc(r, lkb, ms);
4381 queue_cast(r, lkb, 0);
4382 break;
4383
4384 default:
4385 log_error(r->res_ls, "receive_convert_reply %x remote %d %x %d",
4386 lkb->lkb_id, le32_to_cpu(ms->m_header.h_nodeid),
4387 le32_to_cpu(ms->m_lkid),
4388 from_dlm_errno(le32_to_cpu(ms->m_result)));
4389 dlm_print_rsb(r);
4390 dlm_print_lkb(lkb);
4391 }
4392}
4393
4394static void _receive_convert_reply(struct dlm_lkb *lkb,
4395 const struct dlm_message *ms, bool local)
4396{
4397 struct dlm_rsb *r = lkb->lkb_resource;
4398 int error;
4399
4400 hold_rsb(r);
4401 lock_rsb(r);
4402
4403 error = validate_message(lkb, ms);
4404 if (error)
4405 goto out;
4406
4407 /* local reply can happen with waiters_mutex held */
4408 error = remove_from_waiters_ms(lkb, ms, local);
4409 if (error)
4410 goto out;
4411
4412 __receive_convert_reply(r, lkb, ms, local);
4413 out:
4414 unlock_rsb(r);
4415 put_rsb(r);
4416}
4417
4418static int receive_convert_reply(struct dlm_ls *ls,
4419 const struct dlm_message *ms)
4420{
4421 struct dlm_lkb *lkb;
4422 int error;
4423
4424 error = find_lkb(ls, le32_to_cpu(ms->m_remid), &lkb);
4425 if (error)
4426 return error;
4427
4428 _receive_convert_reply(lkb, ms, false);
4429 dlm_put_lkb(lkb);
4430 return 0;
4431}
4432
4433static void _receive_unlock_reply(struct dlm_lkb *lkb,
4434 const struct dlm_message *ms, bool local)
4435{
4436 struct dlm_rsb *r = lkb->lkb_resource;
4437 int error;
4438
4439 hold_rsb(r);
4440 lock_rsb(r);
4441
4442 error = validate_message(lkb, ms);
4443 if (error)
4444 goto out;
4445
4446 /* local reply can happen with waiters_mutex held */
4447 error = remove_from_waiters_ms(lkb, ms, local);
4448 if (error)
4449 goto out;
4450
4451 /* this is the value returned from do_unlock() on the master */
4452
4453 switch (from_dlm_errno(le32_to_cpu(ms->m_result))) {
4454 case -DLM_EUNLOCK:
4455 receive_flags_reply(lkb, ms, local);
4456 remove_lock_pc(r, lkb);
4457 queue_cast(r, lkb, -DLM_EUNLOCK);
4458 break;
4459 case -ENOENT:
4460 break;
4461 default:
4462 log_error(r->res_ls, "receive_unlock_reply %x error %d",
4463 lkb->lkb_id, from_dlm_errno(le32_to_cpu(ms->m_result)));
4464 }
4465 out:
4466 unlock_rsb(r);
4467 put_rsb(r);
4468}
4469
4470static int receive_unlock_reply(struct dlm_ls *ls,
4471 const struct dlm_message *ms)
4472{
4473 struct dlm_lkb *lkb;
4474 int error;
4475
4476 error = find_lkb(ls, le32_to_cpu(ms->m_remid), &lkb);
4477 if (error)
4478 return error;
4479
4480 _receive_unlock_reply(lkb, ms, false);
4481 dlm_put_lkb(lkb);
4482 return 0;
4483}
4484
4485static void _receive_cancel_reply(struct dlm_lkb *lkb,
4486 const struct dlm_message *ms, bool local)
4487{
4488 struct dlm_rsb *r = lkb->lkb_resource;
4489 int error;
4490
4491 hold_rsb(r);
4492 lock_rsb(r);
4493
4494 error = validate_message(lkb, ms);
4495 if (error)
4496 goto out;
4497
4498 /* local reply can happen with waiters_mutex held */
4499 error = remove_from_waiters_ms(lkb, ms, local);
4500 if (error)
4501 goto out;
4502
4503 /* this is the value returned from do_cancel() on the master */
4504
4505 switch (from_dlm_errno(le32_to_cpu(ms->m_result))) {
4506 case -DLM_ECANCEL:
4507 receive_flags_reply(lkb, ms, local);
4508 revert_lock_pc(r, lkb);
4509 queue_cast(r, lkb, -DLM_ECANCEL);
4510 break;
4511 case 0:
4512 break;
4513 default:
4514 log_error(r->res_ls, "receive_cancel_reply %x error %d",
4515 lkb->lkb_id,
4516 from_dlm_errno(le32_to_cpu(ms->m_result)));
4517 }
4518 out:
4519 unlock_rsb(r);
4520 put_rsb(r);
4521}
4522
4523static int receive_cancel_reply(struct dlm_ls *ls,
4524 const struct dlm_message *ms)
4525{
4526 struct dlm_lkb *lkb;
4527 int error;
4528
4529 error = find_lkb(ls, le32_to_cpu(ms->m_remid), &lkb);
4530 if (error)
4531 return error;
4532
4533 _receive_cancel_reply(lkb, ms, false);
4534 dlm_put_lkb(lkb);
4535 return 0;
4536}
4537
4538static void receive_lookup_reply(struct dlm_ls *ls,
4539 const struct dlm_message *ms)
4540{
4541 struct dlm_lkb *lkb;
4542 struct dlm_rsb *r;
4543 int error, ret_nodeid;
4544 int do_lookup_list = 0;
4545
4546 error = find_lkb(ls, le32_to_cpu(ms->m_lkid), &lkb);
4547 if (error) {
4548 log_error(ls, "%s no lkid %x", __func__,
4549 le32_to_cpu(ms->m_lkid));
4550 return;
4551 }
4552
4553 /* ms->m_result is the value returned by dlm_master_lookup on dir node
4554 FIXME: will a non-zero error ever be returned? */
4555
4556 r = lkb->lkb_resource;
4557 hold_rsb(r);
4558 lock_rsb(r);
4559
4560 error = remove_from_waiters(lkb, DLM_MSG_LOOKUP_REPLY);
4561 if (error)
4562 goto out;
4563
4564 ret_nodeid = le32_to_cpu(ms->m_nodeid);
4565
4566 /* We sometimes receive a request from the dir node for this
4567 rsb before we've received the dir node's loookup_reply for it.
4568 The request from the dir node implies we're the master, so we set
4569 ourself as master in receive_request_reply, and verify here that
4570 we are indeed the master. */
4571
4572 if (r->res_master_nodeid && (r->res_master_nodeid != ret_nodeid)) {
4573 /* This should never happen */
4574 log_error(ls, "receive_lookup_reply %x from %d ret %d "
4575 "master %d dir %d our %d first %x %s",
4576 lkb->lkb_id, le32_to_cpu(ms->m_header.h_nodeid),
4577 ret_nodeid, r->res_master_nodeid, r->res_dir_nodeid,
4578 dlm_our_nodeid(), r->res_first_lkid, r->res_name);
4579 }
4580
4581 if (ret_nodeid == dlm_our_nodeid()) {
4582 r->res_master_nodeid = ret_nodeid;
4583 r->res_nodeid = 0;
4584 do_lookup_list = 1;
4585 r->res_first_lkid = 0;
4586 } else if (ret_nodeid == -1) {
4587 /* the remote node doesn't believe it's the dir node */
4588 log_error(ls, "receive_lookup_reply %x from %d bad ret_nodeid",
4589 lkb->lkb_id, le32_to_cpu(ms->m_header.h_nodeid));
4590 r->res_master_nodeid = 0;
4591 r->res_nodeid = -1;
4592 lkb->lkb_nodeid = -1;
4593 } else {
4594 /* set_master() will set lkb_nodeid from r */
4595 r->res_master_nodeid = ret_nodeid;
4596 r->res_nodeid = ret_nodeid;
4597 }
4598
4599 if (is_overlap(lkb)) {
4600 log_debug(ls, "receive_lookup_reply %x unlock %x",
4601 lkb->lkb_id, dlm_iflags_val(lkb));
4602 queue_cast_overlap(r, lkb);
4603 unhold_lkb(lkb); /* undoes create_lkb() */
4604 goto out_list;
4605 }
4606
4607 _request_lock(r, lkb);
4608
4609 out_list:
4610 if (do_lookup_list)
4611 process_lookup_list(r);
4612 out:
4613 unlock_rsb(r);
4614 put_rsb(r);
4615 dlm_put_lkb(lkb);
4616}
4617
4618static void _receive_message(struct dlm_ls *ls, const struct dlm_message *ms,
4619 uint32_t saved_seq)
4620{
4621 int error = 0, noent = 0;
4622
4623 if (WARN_ON_ONCE(!dlm_is_member(ls, le32_to_cpu(ms->m_header.h_nodeid)))) {
4624 log_limit(ls, "receive %d from non-member %d %x %x %d",
4625 le32_to_cpu(ms->m_type),
4626 le32_to_cpu(ms->m_header.h_nodeid),
4627 le32_to_cpu(ms->m_lkid), le32_to_cpu(ms->m_remid),
4628 from_dlm_errno(le32_to_cpu(ms->m_result)));
4629 return;
4630 }
4631
4632 switch (ms->m_type) {
4633
4634 /* messages sent to a master node */
4635
4636 case cpu_to_le32(DLM_MSG_REQUEST):
4637 error = receive_request(ls, ms);
4638 break;
4639
4640 case cpu_to_le32(DLM_MSG_CONVERT):
4641 error = receive_convert(ls, ms);
4642 break;
4643
4644 case cpu_to_le32(DLM_MSG_UNLOCK):
4645 error = receive_unlock(ls, ms);
4646 break;
4647
4648 case cpu_to_le32(DLM_MSG_CANCEL):
4649 noent = 1;
4650 error = receive_cancel(ls, ms);
4651 break;
4652
4653 /* messages sent from a master node (replies to above) */
4654
4655 case cpu_to_le32(DLM_MSG_REQUEST_REPLY):
4656 error = receive_request_reply(ls, ms);
4657 break;
4658
4659 case cpu_to_le32(DLM_MSG_CONVERT_REPLY):
4660 error = receive_convert_reply(ls, ms);
4661 break;
4662
4663 case cpu_to_le32(DLM_MSG_UNLOCK_REPLY):
4664 error = receive_unlock_reply(ls, ms);
4665 break;
4666
4667 case cpu_to_le32(DLM_MSG_CANCEL_REPLY):
4668 error = receive_cancel_reply(ls, ms);
4669 break;
4670
4671 /* messages sent from a master node (only two types of async msg) */
4672
4673 case cpu_to_le32(DLM_MSG_GRANT):
4674 noent = 1;
4675 error = receive_grant(ls, ms);
4676 break;
4677
4678 case cpu_to_le32(DLM_MSG_BAST):
4679 noent = 1;
4680 error = receive_bast(ls, ms);
4681 break;
4682
4683 /* messages sent to a dir node */
4684
4685 case cpu_to_le32(DLM_MSG_LOOKUP):
4686 receive_lookup(ls, ms);
4687 break;
4688
4689 case cpu_to_le32(DLM_MSG_REMOVE):
4690 receive_remove(ls, ms);
4691 break;
4692
4693 /* messages sent from a dir node (remove has no reply) */
4694
4695 case cpu_to_le32(DLM_MSG_LOOKUP_REPLY):
4696 receive_lookup_reply(ls, ms);
4697 break;
4698
4699 /* other messages */
4700
4701 case cpu_to_le32(DLM_MSG_PURGE):
4702 receive_purge(ls, ms);
4703 break;
4704
4705 default:
4706 log_error(ls, "unknown message type %d",
4707 le32_to_cpu(ms->m_type));
4708 }
4709
4710 /*
4711 * When checking for ENOENT, we're checking the result of
4712 * find_lkb(m_remid):
4713 *
4714 * The lock id referenced in the message wasn't found. This may
4715 * happen in normal usage for the async messages and cancel, so
4716 * only use log_debug for them.
4717 *
4718 * Some errors are expected and normal.
4719 */
4720
4721 if (error == -ENOENT && noent) {
4722 log_debug(ls, "receive %d no %x remote %d %x saved_seq %u",
4723 le32_to_cpu(ms->m_type), le32_to_cpu(ms->m_remid),
4724 le32_to_cpu(ms->m_header.h_nodeid),
4725 le32_to_cpu(ms->m_lkid), saved_seq);
4726 } else if (error == -ENOENT) {
4727 log_error(ls, "receive %d no %x remote %d %x saved_seq %u",
4728 le32_to_cpu(ms->m_type), le32_to_cpu(ms->m_remid),
4729 le32_to_cpu(ms->m_header.h_nodeid),
4730 le32_to_cpu(ms->m_lkid), saved_seq);
4731
4732 if (ms->m_type == cpu_to_le32(DLM_MSG_CONVERT))
4733 dlm_dump_rsb_hash(ls, le32_to_cpu(ms->m_hash));
4734 }
4735
4736 if (error == -EINVAL) {
4737 log_error(ls, "receive %d inval from %d lkid %x remid %x "
4738 "saved_seq %u",
4739 le32_to_cpu(ms->m_type),
4740 le32_to_cpu(ms->m_header.h_nodeid),
4741 le32_to_cpu(ms->m_lkid), le32_to_cpu(ms->m_remid),
4742 saved_seq);
4743 }
4744}
4745
4746/* If the lockspace is in recovery mode (locking stopped), then normal
4747 messages are saved on the requestqueue for processing after recovery is
4748 done. When not in recovery mode, we wait for dlm_recoverd to drain saved
4749 messages off the requestqueue before we process new ones. This occurs right
4750 after recovery completes when we transition from saving all messages on
4751 requestqueue, to processing all the saved messages, to processing new
4752 messages as they arrive. */
4753
4754static void dlm_receive_message(struct dlm_ls *ls, const struct dlm_message *ms,
4755 int nodeid)
4756{
4757 if (dlm_locking_stopped(ls)) {
4758 /* If we were a member of this lockspace, left, and rejoined,
4759 other nodes may still be sending us messages from the
4760 lockspace generation before we left. */
4761 if (WARN_ON_ONCE(!ls->ls_generation)) {
4762 log_limit(ls, "receive %d from %d ignore old gen",
4763 le32_to_cpu(ms->m_type), nodeid);
4764 return;
4765 }
4766
4767 dlm_add_requestqueue(ls, nodeid, ms);
4768 } else {
4769 dlm_wait_requestqueue(ls);
4770 _receive_message(ls, ms, 0);
4771 }
4772}
4773
4774/* This is called by dlm_recoverd to process messages that were saved on
4775 the requestqueue. */
4776
4777void dlm_receive_message_saved(struct dlm_ls *ls, const struct dlm_message *ms,
4778 uint32_t saved_seq)
4779{
4780 _receive_message(ls, ms, saved_seq);
4781}
4782
4783/* This is called by the midcomms layer when something is received for
4784 the lockspace. It could be either a MSG (normal message sent as part of
4785 standard locking activity) or an RCOM (recovery message sent as part of
4786 lockspace recovery). */
4787
4788void dlm_receive_buffer(const union dlm_packet *p, int nodeid)
4789{
4790 const struct dlm_header *hd = &p->header;
4791 struct dlm_ls *ls;
4792 int type = 0;
4793
4794 switch (hd->h_cmd) {
4795 case DLM_MSG:
4796 type = le32_to_cpu(p->message.m_type);
4797 break;
4798 case DLM_RCOM:
4799 type = le32_to_cpu(p->rcom.rc_type);
4800 break;
4801 default:
4802 log_print("invalid h_cmd %d from %u", hd->h_cmd, nodeid);
4803 return;
4804 }
4805
4806 if (le32_to_cpu(hd->h_nodeid) != nodeid) {
4807 log_print("invalid h_nodeid %d from %d lockspace %x",
4808 le32_to_cpu(hd->h_nodeid), nodeid,
4809 le32_to_cpu(hd->u.h_lockspace));
4810 return;
4811 }
4812
4813 ls = dlm_find_lockspace_global(le32_to_cpu(hd->u.h_lockspace));
4814 if (!ls) {
4815 if (dlm_config.ci_log_debug) {
4816 printk_ratelimited(KERN_DEBUG "dlm: invalid lockspace "
4817 "%u from %d cmd %d type %d\n",
4818 le32_to_cpu(hd->u.h_lockspace), nodeid,
4819 hd->h_cmd, type);
4820 }
4821
4822 if (hd->h_cmd == DLM_RCOM && type == DLM_RCOM_STATUS)
4823 dlm_send_ls_not_ready(nodeid, &p->rcom);
4824 return;
4825 }
4826
4827 /* this rwsem allows dlm_ls_stop() to wait for all dlm_recv threads to
4828 be inactive (in this ls) before transitioning to recovery mode */
4829
4830 down_read(&ls->ls_recv_active);
4831 if (hd->h_cmd == DLM_MSG)
4832 dlm_receive_message(ls, &p->message, nodeid);
4833 else if (hd->h_cmd == DLM_RCOM)
4834 dlm_receive_rcom(ls, &p->rcom, nodeid);
4835 else
4836 log_error(ls, "invalid h_cmd %d from %d lockspace %x",
4837 hd->h_cmd, nodeid, le32_to_cpu(hd->u.h_lockspace));
4838 up_read(&ls->ls_recv_active);
4839
4840 dlm_put_lockspace(ls);
4841}
4842
4843static void recover_convert_waiter(struct dlm_ls *ls, struct dlm_lkb *lkb,
4844 struct dlm_message *ms_local)
4845{
4846 if (middle_conversion(lkb)) {
4847 hold_lkb(lkb);
4848 memset(ms_local, 0, sizeof(struct dlm_message));
4849 ms_local->m_type = cpu_to_le32(DLM_MSG_CONVERT_REPLY);
4850 ms_local->m_result = cpu_to_le32(to_dlm_errno(-EINPROGRESS));
4851 ms_local->m_header.h_nodeid = cpu_to_le32(lkb->lkb_nodeid);
4852 _receive_convert_reply(lkb, ms_local, true);
4853
4854 /* Same special case as in receive_rcom_lock_args() */
4855 lkb->lkb_grmode = DLM_LOCK_IV;
4856 rsb_set_flag(lkb->lkb_resource, RSB_RECOVER_CONVERT);
4857 unhold_lkb(lkb);
4858
4859 } else if (lkb->lkb_rqmode >= lkb->lkb_grmode) {
4860 set_bit(DLM_IFL_RESEND_BIT, &lkb->lkb_iflags);
4861 }
4862
4863 /* lkb->lkb_rqmode < lkb->lkb_grmode shouldn't happen since down
4864 conversions are async; there's no reply from the remote master */
4865}
4866
4867/* A waiting lkb needs recovery if the master node has failed, or
4868 the master node is changing (only when no directory is used) */
4869
4870static int waiter_needs_recovery(struct dlm_ls *ls, struct dlm_lkb *lkb,
4871 int dir_nodeid)
4872{
4873 if (dlm_no_directory(ls))
4874 return 1;
4875
4876 if (dlm_is_removed(ls, lkb->lkb_wait_nodeid))
4877 return 1;
4878
4879 return 0;
4880}
4881
4882/* Recovery for locks that are waiting for replies from nodes that are now
4883 gone. We can just complete unlocks and cancels by faking a reply from the
4884 dead node. Requests and up-conversions we flag to be resent after
4885 recovery. Down-conversions can just be completed with a fake reply like
4886 unlocks. Conversions between PR and CW need special attention. */
4887
4888void dlm_recover_waiters_pre(struct dlm_ls *ls)
4889{
4890 struct dlm_lkb *lkb, *safe;
4891 struct dlm_message *ms_local;
4892 int wait_type, local_unlock_result, local_cancel_result;
4893 int dir_nodeid;
4894
4895 ms_local = kmalloc(sizeof(*ms_local), GFP_KERNEL);
4896 if (!ms_local)
4897 return;
4898
4899 mutex_lock(&ls->ls_waiters_mutex);
4900
4901 list_for_each_entry_safe(lkb, safe, &ls->ls_waiters, lkb_wait_reply) {
4902
4903 dir_nodeid = dlm_dir_nodeid(lkb->lkb_resource);
4904
4905 /* exclude debug messages about unlocks because there can be so
4906 many and they aren't very interesting */
4907
4908 if (lkb->lkb_wait_type != DLM_MSG_UNLOCK) {
4909 log_debug(ls, "waiter %x remote %x msg %d r_nodeid %d "
4910 "lkb_nodeid %d wait_nodeid %d dir_nodeid %d",
4911 lkb->lkb_id,
4912 lkb->lkb_remid,
4913 lkb->lkb_wait_type,
4914 lkb->lkb_resource->res_nodeid,
4915 lkb->lkb_nodeid,
4916 lkb->lkb_wait_nodeid,
4917 dir_nodeid);
4918 }
4919
4920 /* all outstanding lookups, regardless of destination will be
4921 resent after recovery is done */
4922
4923 if (lkb->lkb_wait_type == DLM_MSG_LOOKUP) {
4924 set_bit(DLM_IFL_RESEND_BIT, &lkb->lkb_iflags);
4925 continue;
4926 }
4927
4928 if (!waiter_needs_recovery(ls, lkb, dir_nodeid))
4929 continue;
4930
4931 wait_type = lkb->lkb_wait_type;
4932 local_unlock_result = -DLM_EUNLOCK;
4933 local_cancel_result = -DLM_ECANCEL;
4934
4935 /* Main reply may have been received leaving a zero wait_type,
4936 but a reply for the overlapping op may not have been
4937 received. In that case we need to fake the appropriate
4938 reply for the overlap op. */
4939
4940 if (!wait_type) {
4941 if (is_overlap_cancel(lkb)) {
4942 wait_type = DLM_MSG_CANCEL;
4943 if (lkb->lkb_grmode == DLM_LOCK_IV)
4944 local_cancel_result = 0;
4945 }
4946 if (is_overlap_unlock(lkb)) {
4947 wait_type = DLM_MSG_UNLOCK;
4948 if (lkb->lkb_grmode == DLM_LOCK_IV)
4949 local_unlock_result = -ENOENT;
4950 }
4951
4952 log_debug(ls, "rwpre overlap %x %x %d %d %d",
4953 lkb->lkb_id, dlm_iflags_val(lkb), wait_type,
4954 local_cancel_result, local_unlock_result);
4955 }
4956
4957 switch (wait_type) {
4958
4959 case DLM_MSG_REQUEST:
4960 set_bit(DLM_IFL_RESEND_BIT, &lkb->lkb_iflags);
4961 break;
4962
4963 case DLM_MSG_CONVERT:
4964 recover_convert_waiter(ls, lkb, ms_local);
4965 break;
4966
4967 case DLM_MSG_UNLOCK:
4968 hold_lkb(lkb);
4969 memset(ms_local, 0, sizeof(struct dlm_message));
4970 ms_local->m_type = cpu_to_le32(DLM_MSG_UNLOCK_REPLY);
4971 ms_local->m_result = cpu_to_le32(to_dlm_errno(local_unlock_result));
4972 ms_local->m_header.h_nodeid = cpu_to_le32(lkb->lkb_nodeid);
4973 _receive_unlock_reply(lkb, ms_local, true);
4974 dlm_put_lkb(lkb);
4975 break;
4976
4977 case DLM_MSG_CANCEL:
4978 hold_lkb(lkb);
4979 memset(ms_local, 0, sizeof(struct dlm_message));
4980 ms_local->m_type = cpu_to_le32(DLM_MSG_CANCEL_REPLY);
4981 ms_local->m_result = cpu_to_le32(to_dlm_errno(local_cancel_result));
4982 ms_local->m_header.h_nodeid = cpu_to_le32(lkb->lkb_nodeid);
4983 _receive_cancel_reply(lkb, ms_local, true);
4984 dlm_put_lkb(lkb);
4985 break;
4986
4987 default:
4988 log_error(ls, "invalid lkb wait_type %d %d",
4989 lkb->lkb_wait_type, wait_type);
4990 }
4991 schedule();
4992 }
4993 mutex_unlock(&ls->ls_waiters_mutex);
4994 kfree(ms_local);
4995}
4996
4997static struct dlm_lkb *find_resend_waiter(struct dlm_ls *ls)
4998{
4999 struct dlm_lkb *lkb = NULL, *iter;
5000
5001 mutex_lock(&ls->ls_waiters_mutex);
5002 list_for_each_entry(iter, &ls->ls_waiters, lkb_wait_reply) {
5003 if (test_bit(DLM_IFL_RESEND_BIT, &iter->lkb_iflags)) {
5004 hold_lkb(iter);
5005 lkb = iter;
5006 break;
5007 }
5008 }
5009 mutex_unlock(&ls->ls_waiters_mutex);
5010
5011 return lkb;
5012}
5013
5014/* Deal with lookups and lkb's marked RESEND from _pre. We may now be the
5015 master or dir-node for r. Processing the lkb may result in it being placed
5016 back on waiters. */
5017
5018/* We do this after normal locking has been enabled and any saved messages
5019 (in requestqueue) have been processed. We should be confident that at
5020 this point we won't get or process a reply to any of these waiting
5021 operations. But, new ops may be coming in on the rsbs/locks here from
5022 userspace or remotely. */
5023
5024/* there may have been an overlap unlock/cancel prior to recovery or after
5025 recovery. if before, the lkb may still have a pos wait_count; if after, the
5026 overlap flag would just have been set and nothing new sent. we can be
5027 confident here than any replies to either the initial op or overlap ops
5028 prior to recovery have been received. */
5029
5030int dlm_recover_waiters_post(struct dlm_ls *ls)
5031{
5032 struct dlm_lkb *lkb;
5033 struct dlm_rsb *r;
5034 int error = 0, mstype, err, oc, ou;
5035
5036 while (1) {
5037 if (dlm_locking_stopped(ls)) {
5038 log_debug(ls, "recover_waiters_post aborted");
5039 error = -EINTR;
5040 break;
5041 }
5042
5043 lkb = find_resend_waiter(ls);
5044 if (!lkb)
5045 break;
5046
5047 r = lkb->lkb_resource;
5048 hold_rsb(r);
5049 lock_rsb(r);
5050
5051 mstype = lkb->lkb_wait_type;
5052 oc = test_and_clear_bit(DLM_IFL_OVERLAP_CANCEL_BIT,
5053 &lkb->lkb_iflags);
5054 ou = test_and_clear_bit(DLM_IFL_OVERLAP_UNLOCK_BIT,
5055 &lkb->lkb_iflags);
5056 err = 0;
5057
5058 log_debug(ls, "waiter %x remote %x msg %d r_nodeid %d "
5059 "lkb_nodeid %d wait_nodeid %d dir_nodeid %d "
5060 "overlap %d %d", lkb->lkb_id, lkb->lkb_remid, mstype,
5061 r->res_nodeid, lkb->lkb_nodeid, lkb->lkb_wait_nodeid,
5062 dlm_dir_nodeid(r), oc, ou);
5063
5064 /* At this point we assume that we won't get a reply to any
5065 previous op or overlap op on this lock. First, do a big
5066 remove_from_waiters() for all previous ops. */
5067
5068 clear_bit(DLM_IFL_RESEND_BIT, &lkb->lkb_iflags);
5069 lkb->lkb_wait_type = 0;
5070 /* drop all wait_count references we still
5071 * hold a reference for this iteration.
5072 */
5073 while (!atomic_dec_and_test(&lkb->lkb_wait_count))
5074 unhold_lkb(lkb);
5075
5076 mutex_lock(&ls->ls_waiters_mutex);
5077 list_del_init(&lkb->lkb_wait_reply);
5078 mutex_unlock(&ls->ls_waiters_mutex);
5079
5080 if (oc || ou) {
5081 /* do an unlock or cancel instead of resending */
5082 switch (mstype) {
5083 case DLM_MSG_LOOKUP:
5084 case DLM_MSG_REQUEST:
5085 queue_cast(r, lkb, ou ? -DLM_EUNLOCK :
5086 -DLM_ECANCEL);
5087 unhold_lkb(lkb); /* undoes create_lkb() */
5088 break;
5089 case DLM_MSG_CONVERT:
5090 if (oc) {
5091 queue_cast(r, lkb, -DLM_ECANCEL);
5092 } else {
5093 lkb->lkb_exflags |= DLM_LKF_FORCEUNLOCK;
5094 _unlock_lock(r, lkb);
5095 }
5096 break;
5097 default:
5098 err = 1;
5099 }
5100 } else {
5101 switch (mstype) {
5102 case DLM_MSG_LOOKUP:
5103 case DLM_MSG_REQUEST:
5104 _request_lock(r, lkb);
5105 if (is_master(r))
5106 confirm_master(r, 0);
5107 break;
5108 case DLM_MSG_CONVERT:
5109 _convert_lock(r, lkb);
5110 break;
5111 default:
5112 err = 1;
5113 }
5114 }
5115
5116 if (err) {
5117 log_error(ls, "waiter %x msg %d r_nodeid %d "
5118 "dir_nodeid %d overlap %d %d",
5119 lkb->lkb_id, mstype, r->res_nodeid,
5120 dlm_dir_nodeid(r), oc, ou);
5121 }
5122 unlock_rsb(r);
5123 put_rsb(r);
5124 dlm_put_lkb(lkb);
5125 }
5126
5127 return error;
5128}
5129
5130static void purge_mstcpy_list(struct dlm_ls *ls, struct dlm_rsb *r,
5131 struct list_head *list)
5132{
5133 struct dlm_lkb *lkb, *safe;
5134
5135 list_for_each_entry_safe(lkb, safe, list, lkb_statequeue) {
5136 if (!is_master_copy(lkb))
5137 continue;
5138
5139 /* don't purge lkbs we've added in recover_master_copy for
5140 the current recovery seq */
5141
5142 if (lkb->lkb_recover_seq == ls->ls_recover_seq)
5143 continue;
5144
5145 del_lkb(r, lkb);
5146
5147 /* this put should free the lkb */
5148 if (!dlm_put_lkb(lkb))
5149 log_error(ls, "purged mstcpy lkb not released");
5150 }
5151}
5152
5153void dlm_purge_mstcpy_locks(struct dlm_rsb *r)
5154{
5155 struct dlm_ls *ls = r->res_ls;
5156
5157 purge_mstcpy_list(ls, r, &r->res_grantqueue);
5158 purge_mstcpy_list(ls, r, &r->res_convertqueue);
5159 purge_mstcpy_list(ls, r, &r->res_waitqueue);
5160}
5161
5162static void purge_dead_list(struct dlm_ls *ls, struct dlm_rsb *r,
5163 struct list_head *list,
5164 int nodeid_gone, unsigned int *count)
5165{
5166 struct dlm_lkb *lkb, *safe;
5167
5168 list_for_each_entry_safe(lkb, safe, list, lkb_statequeue) {
5169 if (!is_master_copy(lkb))
5170 continue;
5171
5172 if ((lkb->lkb_nodeid == nodeid_gone) ||
5173 dlm_is_removed(ls, lkb->lkb_nodeid)) {
5174
5175 /* tell recover_lvb to invalidate the lvb
5176 because a node holding EX/PW failed */
5177 if ((lkb->lkb_exflags & DLM_LKF_VALBLK) &&
5178 (lkb->lkb_grmode >= DLM_LOCK_PW)) {
5179 rsb_set_flag(r, RSB_RECOVER_LVB_INVAL);
5180 }
5181
5182 del_lkb(r, lkb);
5183
5184 /* this put should free the lkb */
5185 if (!dlm_put_lkb(lkb))
5186 log_error(ls, "purged dead lkb not released");
5187
5188 rsb_set_flag(r, RSB_RECOVER_GRANT);
5189
5190 (*count)++;
5191 }
5192 }
5193}
5194
5195/* Get rid of locks held by nodes that are gone. */
5196
5197void dlm_recover_purge(struct dlm_ls *ls)
5198{
5199 struct dlm_rsb *r;
5200 struct dlm_member *memb;
5201 int nodes_count = 0;
5202 int nodeid_gone = 0;
5203 unsigned int lkb_count = 0;
5204
5205 /* cache one removed nodeid to optimize the common
5206 case of a single node removed */
5207
5208 list_for_each_entry(memb, &ls->ls_nodes_gone, list) {
5209 nodes_count++;
5210 nodeid_gone = memb->nodeid;
5211 }
5212
5213 if (!nodes_count)
5214 return;
5215
5216 down_write(&ls->ls_root_sem);
5217 list_for_each_entry(r, &ls->ls_root_list, res_root_list) {
5218 hold_rsb(r);
5219 lock_rsb(r);
5220 if (is_master(r)) {
5221 purge_dead_list(ls, r, &r->res_grantqueue,
5222 nodeid_gone, &lkb_count);
5223 purge_dead_list(ls, r, &r->res_convertqueue,
5224 nodeid_gone, &lkb_count);
5225 purge_dead_list(ls, r, &r->res_waitqueue,
5226 nodeid_gone, &lkb_count);
5227 }
5228 unlock_rsb(r);
5229 unhold_rsb(r);
5230 cond_resched();
5231 }
5232 up_write(&ls->ls_root_sem);
5233
5234 if (lkb_count)
5235 log_rinfo(ls, "dlm_recover_purge %u locks for %u nodes",
5236 lkb_count, nodes_count);
5237}
5238
5239static struct dlm_rsb *find_grant_rsb(struct dlm_ls *ls, int bucket)
5240{
5241 struct rb_node *n;
5242 struct dlm_rsb *r;
5243
5244 spin_lock(&ls->ls_rsbtbl[bucket].lock);
5245 for (n = rb_first(&ls->ls_rsbtbl[bucket].keep); n; n = rb_next(n)) {
5246 r = rb_entry(n, struct dlm_rsb, res_hashnode);
5247
5248 if (!rsb_flag(r, RSB_RECOVER_GRANT))
5249 continue;
5250 if (!is_master(r)) {
5251 rsb_clear_flag(r, RSB_RECOVER_GRANT);
5252 continue;
5253 }
5254 hold_rsb(r);
5255 spin_unlock(&ls->ls_rsbtbl[bucket].lock);
5256 return r;
5257 }
5258 spin_unlock(&ls->ls_rsbtbl[bucket].lock);
5259 return NULL;
5260}
5261
5262/*
5263 * Attempt to grant locks on resources that we are the master of.
5264 * Locks may have become grantable during recovery because locks
5265 * from departed nodes have been purged (or not rebuilt), allowing
5266 * previously blocked locks to now be granted. The subset of rsb's
5267 * we are interested in are those with lkb's on either the convert or
5268 * waiting queues.
5269 *
5270 * Simplest would be to go through each master rsb and check for non-empty
5271 * convert or waiting queues, and attempt to grant on those rsbs.
5272 * Checking the queues requires lock_rsb, though, for which we'd need
5273 * to release the rsbtbl lock. This would make iterating through all
5274 * rsb's very inefficient. So, we rely on earlier recovery routines
5275 * to set RECOVER_GRANT on any rsb's that we should attempt to grant
5276 * locks for.
5277 */
5278
5279void dlm_recover_grant(struct dlm_ls *ls)
5280{
5281 struct dlm_rsb *r;
5282 int bucket = 0;
5283 unsigned int count = 0;
5284 unsigned int rsb_count = 0;
5285 unsigned int lkb_count = 0;
5286
5287 while (1) {
5288 r = find_grant_rsb(ls, bucket);
5289 if (!r) {
5290 if (bucket == ls->ls_rsbtbl_size - 1)
5291 break;
5292 bucket++;
5293 continue;
5294 }
5295 rsb_count++;
5296 count = 0;
5297 lock_rsb(r);
5298 /* the RECOVER_GRANT flag is checked in the grant path */
5299 grant_pending_locks(r, &count);
5300 rsb_clear_flag(r, RSB_RECOVER_GRANT);
5301 lkb_count += count;
5302 confirm_master(r, 0);
5303 unlock_rsb(r);
5304 put_rsb(r);
5305 cond_resched();
5306 }
5307
5308 if (lkb_count)
5309 log_rinfo(ls, "dlm_recover_grant %u locks on %u resources",
5310 lkb_count, rsb_count);
5311}
5312
5313static struct dlm_lkb *search_remid_list(struct list_head *head, int nodeid,
5314 uint32_t remid)
5315{
5316 struct dlm_lkb *lkb;
5317
5318 list_for_each_entry(lkb, head, lkb_statequeue) {
5319 if (lkb->lkb_nodeid == nodeid && lkb->lkb_remid == remid)
5320 return lkb;
5321 }
5322 return NULL;
5323}
5324
5325static struct dlm_lkb *search_remid(struct dlm_rsb *r, int nodeid,
5326 uint32_t remid)
5327{
5328 struct dlm_lkb *lkb;
5329
5330 lkb = search_remid_list(&r->res_grantqueue, nodeid, remid);
5331 if (lkb)
5332 return lkb;
5333 lkb = search_remid_list(&r->res_convertqueue, nodeid, remid);
5334 if (lkb)
5335 return lkb;
5336 lkb = search_remid_list(&r->res_waitqueue, nodeid, remid);
5337 if (lkb)
5338 return lkb;
5339 return NULL;
5340}
5341
5342/* needs at least dlm_rcom + rcom_lock */
5343static int receive_rcom_lock_args(struct dlm_ls *ls, struct dlm_lkb *lkb,
5344 struct dlm_rsb *r, const struct dlm_rcom *rc)
5345{
5346 struct rcom_lock *rl = (struct rcom_lock *) rc->rc_buf;
5347
5348 lkb->lkb_nodeid = le32_to_cpu(rc->rc_header.h_nodeid);
5349 lkb->lkb_ownpid = le32_to_cpu(rl->rl_ownpid);
5350 lkb->lkb_remid = le32_to_cpu(rl->rl_lkid);
5351 lkb->lkb_exflags = le32_to_cpu(rl->rl_exflags);
5352 dlm_set_dflags_val(lkb, le32_to_cpu(rl->rl_flags));
5353 set_bit(DLM_IFL_MSTCPY_BIT, &lkb->lkb_iflags);
5354 lkb->lkb_lvbseq = le32_to_cpu(rl->rl_lvbseq);
5355 lkb->lkb_rqmode = rl->rl_rqmode;
5356 lkb->lkb_grmode = rl->rl_grmode;
5357 /* don't set lkb_status because add_lkb wants to itself */
5358
5359 lkb->lkb_bastfn = (rl->rl_asts & DLM_CB_BAST) ? &fake_bastfn : NULL;
5360 lkb->lkb_astfn = (rl->rl_asts & DLM_CB_CAST) ? &fake_astfn : NULL;
5361
5362 if (lkb->lkb_exflags & DLM_LKF_VALBLK) {
5363 int lvblen = le16_to_cpu(rc->rc_header.h_length) -
5364 sizeof(struct dlm_rcom) - sizeof(struct rcom_lock);
5365 if (lvblen > ls->ls_lvblen)
5366 return -EINVAL;
5367 lkb->lkb_lvbptr = dlm_allocate_lvb(ls);
5368 if (!lkb->lkb_lvbptr)
5369 return -ENOMEM;
5370 memcpy(lkb->lkb_lvbptr, rl->rl_lvb, lvblen);
5371 }
5372
5373 /* Conversions between PR and CW (middle modes) need special handling.
5374 The real granted mode of these converting locks cannot be determined
5375 until all locks have been rebuilt on the rsb (recover_conversion) */
5376
5377 if (rl->rl_wait_type == cpu_to_le16(DLM_MSG_CONVERT) &&
5378 middle_conversion(lkb)) {
5379 rl->rl_status = DLM_LKSTS_CONVERT;
5380 lkb->lkb_grmode = DLM_LOCK_IV;
5381 rsb_set_flag(r, RSB_RECOVER_CONVERT);
5382 }
5383
5384 return 0;
5385}
5386
5387/* This lkb may have been recovered in a previous aborted recovery so we need
5388 to check if the rsb already has an lkb with the given remote nodeid/lkid.
5389 If so we just send back a standard reply. If not, we create a new lkb with
5390 the given values and send back our lkid. We send back our lkid by sending
5391 back the rcom_lock struct we got but with the remid field filled in. */
5392
5393/* needs at least dlm_rcom + rcom_lock */
5394int dlm_recover_master_copy(struct dlm_ls *ls, const struct dlm_rcom *rc,
5395 __le32 *rl_remid, __le32 *rl_result)
5396{
5397 struct rcom_lock *rl = (struct rcom_lock *) rc->rc_buf;
5398 struct dlm_rsb *r;
5399 struct dlm_lkb *lkb;
5400 uint32_t remid = 0;
5401 int from_nodeid = le32_to_cpu(rc->rc_header.h_nodeid);
5402 int error;
5403
5404 /* init rl_remid with rcom lock rl_remid */
5405 *rl_remid = rl->rl_remid;
5406
5407 if (rl->rl_parent_lkid) {
5408 error = -EOPNOTSUPP;
5409 goto out;
5410 }
5411
5412 remid = le32_to_cpu(rl->rl_lkid);
5413
5414 /* In general we expect the rsb returned to be R_MASTER, but we don't
5415 have to require it. Recovery of masters on one node can overlap
5416 recovery of locks on another node, so one node can send us MSTCPY
5417 locks before we've made ourselves master of this rsb. We can still
5418 add new MSTCPY locks that we receive here without any harm; when
5419 we make ourselves master, dlm_recover_masters() won't touch the
5420 MSTCPY locks we've received early. */
5421
5422 error = find_rsb(ls, rl->rl_name, le16_to_cpu(rl->rl_namelen),
5423 from_nodeid, R_RECEIVE_RECOVER, &r);
5424 if (error)
5425 goto out;
5426
5427 lock_rsb(r);
5428
5429 if (dlm_no_directory(ls) && (dlm_dir_nodeid(r) != dlm_our_nodeid())) {
5430 log_error(ls, "dlm_recover_master_copy remote %d %x not dir",
5431 from_nodeid, remid);
5432 error = -EBADR;
5433 goto out_unlock;
5434 }
5435
5436 lkb = search_remid(r, from_nodeid, remid);
5437 if (lkb) {
5438 error = -EEXIST;
5439 goto out_remid;
5440 }
5441
5442 error = create_lkb(ls, &lkb);
5443 if (error)
5444 goto out_unlock;
5445
5446 error = receive_rcom_lock_args(ls, lkb, r, rc);
5447 if (error) {
5448 __put_lkb(ls, lkb);
5449 goto out_unlock;
5450 }
5451
5452 attach_lkb(r, lkb);
5453 add_lkb(r, lkb, rl->rl_status);
5454 ls->ls_recover_locks_in++;
5455
5456 if (!list_empty(&r->res_waitqueue) || !list_empty(&r->res_convertqueue))
5457 rsb_set_flag(r, RSB_RECOVER_GRANT);
5458
5459 out_remid:
5460 /* this is the new value returned to the lock holder for
5461 saving in its process-copy lkb */
5462 *rl_remid = cpu_to_le32(lkb->lkb_id);
5463
5464 lkb->lkb_recover_seq = ls->ls_recover_seq;
5465
5466 out_unlock:
5467 unlock_rsb(r);
5468 put_rsb(r);
5469 out:
5470 if (error && error != -EEXIST)
5471 log_rinfo(ls, "dlm_recover_master_copy remote %d %x error %d",
5472 from_nodeid, remid, error);
5473 *rl_result = cpu_to_le32(error);
5474 return error;
5475}
5476
5477/* needs at least dlm_rcom + rcom_lock */
5478int dlm_recover_process_copy(struct dlm_ls *ls, const struct dlm_rcom *rc,
5479 uint64_t seq)
5480{
5481 struct rcom_lock *rl = (struct rcom_lock *) rc->rc_buf;
5482 struct dlm_rsb *r;
5483 struct dlm_lkb *lkb;
5484 uint32_t lkid, remid;
5485 int error, result;
5486
5487 lkid = le32_to_cpu(rl->rl_lkid);
5488 remid = le32_to_cpu(rl->rl_remid);
5489 result = le32_to_cpu(rl->rl_result);
5490
5491 error = find_lkb(ls, lkid, &lkb);
5492 if (error) {
5493 log_error(ls, "dlm_recover_process_copy no %x remote %d %x %d",
5494 lkid, le32_to_cpu(rc->rc_header.h_nodeid), remid,
5495 result);
5496 return error;
5497 }
5498
5499 r = lkb->lkb_resource;
5500 hold_rsb(r);
5501 lock_rsb(r);
5502
5503 if (!is_process_copy(lkb)) {
5504 log_error(ls, "dlm_recover_process_copy bad %x remote %d %x %d",
5505 lkid, le32_to_cpu(rc->rc_header.h_nodeid), remid,
5506 result);
5507 dlm_dump_rsb(r);
5508 unlock_rsb(r);
5509 put_rsb(r);
5510 dlm_put_lkb(lkb);
5511 return -EINVAL;
5512 }
5513
5514 switch (result) {
5515 case -EBADR:
5516 /* There's a chance the new master received our lock before
5517 dlm_recover_master_reply(), this wouldn't happen if we did
5518 a barrier between recover_masters and recover_locks. */
5519
5520 log_debug(ls, "dlm_recover_process_copy %x remote %d %x %d",
5521 lkid, le32_to_cpu(rc->rc_header.h_nodeid), remid,
5522 result);
5523
5524 dlm_send_rcom_lock(r, lkb, seq);
5525 goto out;
5526 case -EEXIST:
5527 case 0:
5528 lkb->lkb_remid = remid;
5529 break;
5530 default:
5531 log_error(ls, "dlm_recover_process_copy %x remote %d %x %d unk",
5532 lkid, le32_to_cpu(rc->rc_header.h_nodeid), remid,
5533 result);
5534 }
5535
5536 /* an ack for dlm_recover_locks() which waits for replies from
5537 all the locks it sends to new masters */
5538 dlm_recovered_lock(r);
5539 out:
5540 unlock_rsb(r);
5541 put_rsb(r);
5542 dlm_put_lkb(lkb);
5543
5544 return 0;
5545}
5546
5547int dlm_user_request(struct dlm_ls *ls, struct dlm_user_args *ua,
5548 int mode, uint32_t flags, void *name, unsigned int namelen)
5549{
5550 struct dlm_lkb *lkb;
5551 struct dlm_args args;
5552 bool do_put = true;
5553 int error;
5554
5555 dlm_lock_recovery(ls);
5556
5557 error = create_lkb(ls, &lkb);
5558 if (error) {
5559 kfree(ua);
5560 goto out;
5561 }
5562
5563 trace_dlm_lock_start(ls, lkb, name, namelen, mode, flags);
5564
5565 if (flags & DLM_LKF_VALBLK) {
5566 ua->lksb.sb_lvbptr = kzalloc(DLM_USER_LVB_LEN, GFP_NOFS);
5567 if (!ua->lksb.sb_lvbptr) {
5568 kfree(ua);
5569 error = -ENOMEM;
5570 goto out_put;
5571 }
5572 }
5573 error = set_lock_args(mode, &ua->lksb, flags, namelen, fake_astfn, ua,
5574 fake_bastfn, &args);
5575 if (error) {
5576 kfree(ua->lksb.sb_lvbptr);
5577 ua->lksb.sb_lvbptr = NULL;
5578 kfree(ua);
5579 goto out_put;
5580 }
5581
5582 /* After ua is attached to lkb it will be freed by dlm_free_lkb().
5583 When DLM_DFL_USER_BIT is set, the dlm knows that this is a userspace
5584 lock and that lkb_astparam is the dlm_user_args structure. */
5585 set_bit(DLM_DFL_USER_BIT, &lkb->lkb_dflags);
5586 error = request_lock(ls, lkb, name, namelen, &args);
5587
5588 switch (error) {
5589 case 0:
5590 break;
5591 case -EINPROGRESS:
5592 error = 0;
5593 break;
5594 case -EAGAIN:
5595 error = 0;
5596 fallthrough;
5597 default:
5598 goto out_put;
5599 }
5600
5601 /* add this new lkb to the per-process list of locks */
5602 spin_lock(&ua->proc->locks_spin);
5603 hold_lkb(lkb);
5604 list_add_tail(&lkb->lkb_ownqueue, &ua->proc->locks);
5605 spin_unlock(&ua->proc->locks_spin);
5606 do_put = false;
5607 out_put:
5608 trace_dlm_lock_end(ls, lkb, name, namelen, mode, flags, error, false);
5609 if (do_put)
5610 __put_lkb(ls, lkb);
5611 out:
5612 dlm_unlock_recovery(ls);
5613 return error;
5614}
5615
5616int dlm_user_convert(struct dlm_ls *ls, struct dlm_user_args *ua_tmp,
5617 int mode, uint32_t flags, uint32_t lkid, char *lvb_in)
5618{
5619 struct dlm_lkb *lkb;
5620 struct dlm_args args;
5621 struct dlm_user_args *ua;
5622 int error;
5623
5624 dlm_lock_recovery(ls);
5625
5626 error = find_lkb(ls, lkid, &lkb);
5627 if (error)
5628 goto out;
5629
5630 trace_dlm_lock_start(ls, lkb, NULL, 0, mode, flags);
5631
5632 /* user can change the params on its lock when it converts it, or
5633 add an lvb that didn't exist before */
5634
5635 ua = lkb->lkb_ua;
5636
5637 if (flags & DLM_LKF_VALBLK && !ua->lksb.sb_lvbptr) {
5638 ua->lksb.sb_lvbptr = kzalloc(DLM_USER_LVB_LEN, GFP_NOFS);
5639 if (!ua->lksb.sb_lvbptr) {
5640 error = -ENOMEM;
5641 goto out_put;
5642 }
5643 }
5644 if (lvb_in && ua->lksb.sb_lvbptr)
5645 memcpy(ua->lksb.sb_lvbptr, lvb_in, DLM_USER_LVB_LEN);
5646
5647 ua->xid = ua_tmp->xid;
5648 ua->castparam = ua_tmp->castparam;
5649 ua->castaddr = ua_tmp->castaddr;
5650 ua->bastparam = ua_tmp->bastparam;
5651 ua->bastaddr = ua_tmp->bastaddr;
5652 ua->user_lksb = ua_tmp->user_lksb;
5653
5654 error = set_lock_args(mode, &ua->lksb, flags, 0, fake_astfn, ua,
5655 fake_bastfn, &args);
5656 if (error)
5657 goto out_put;
5658
5659 error = convert_lock(ls, lkb, &args);
5660
5661 if (error == -EINPROGRESS || error == -EAGAIN || error == -EDEADLK)
5662 error = 0;
5663 out_put:
5664 trace_dlm_lock_end(ls, lkb, NULL, 0, mode, flags, error, false);
5665 dlm_put_lkb(lkb);
5666 out:
5667 dlm_unlock_recovery(ls);
5668 kfree(ua_tmp);
5669 return error;
5670}
5671
5672/*
5673 * The caller asks for an orphan lock on a given resource with a given mode.
5674 * If a matching lock exists, it's moved to the owner's list of locks and
5675 * the lkid is returned.
5676 */
5677
5678int dlm_user_adopt_orphan(struct dlm_ls *ls, struct dlm_user_args *ua_tmp,
5679 int mode, uint32_t flags, void *name, unsigned int namelen,
5680 uint32_t *lkid)
5681{
5682 struct dlm_lkb *lkb = NULL, *iter;
5683 struct dlm_user_args *ua;
5684 int found_other_mode = 0;
5685 int rv = 0;
5686
5687 mutex_lock(&ls->ls_orphans_mutex);
5688 list_for_each_entry(iter, &ls->ls_orphans, lkb_ownqueue) {
5689 if (iter->lkb_resource->res_length != namelen)
5690 continue;
5691 if (memcmp(iter->lkb_resource->res_name, name, namelen))
5692 continue;
5693 if (iter->lkb_grmode != mode) {
5694 found_other_mode = 1;
5695 continue;
5696 }
5697
5698 lkb = iter;
5699 list_del_init(&iter->lkb_ownqueue);
5700 clear_bit(DLM_DFL_ORPHAN_BIT, &iter->lkb_dflags);
5701 *lkid = iter->lkb_id;
5702 break;
5703 }
5704 mutex_unlock(&ls->ls_orphans_mutex);
5705
5706 if (!lkb && found_other_mode) {
5707 rv = -EAGAIN;
5708 goto out;
5709 }
5710
5711 if (!lkb) {
5712 rv = -ENOENT;
5713 goto out;
5714 }
5715
5716 lkb->lkb_exflags = flags;
5717 lkb->lkb_ownpid = (int) current->pid;
5718
5719 ua = lkb->lkb_ua;
5720
5721 ua->proc = ua_tmp->proc;
5722 ua->xid = ua_tmp->xid;
5723 ua->castparam = ua_tmp->castparam;
5724 ua->castaddr = ua_tmp->castaddr;
5725 ua->bastparam = ua_tmp->bastparam;
5726 ua->bastaddr = ua_tmp->bastaddr;
5727 ua->user_lksb = ua_tmp->user_lksb;
5728
5729 /*
5730 * The lkb reference from the ls_orphans list was not
5731 * removed above, and is now considered the reference
5732 * for the proc locks list.
5733 */
5734
5735 spin_lock(&ua->proc->locks_spin);
5736 list_add_tail(&lkb->lkb_ownqueue, &ua->proc->locks);
5737 spin_unlock(&ua->proc->locks_spin);
5738 out:
5739 kfree(ua_tmp);
5740 return rv;
5741}
5742
5743int dlm_user_unlock(struct dlm_ls *ls, struct dlm_user_args *ua_tmp,
5744 uint32_t flags, uint32_t lkid, char *lvb_in)
5745{
5746 struct dlm_lkb *lkb;
5747 struct dlm_args args;
5748 struct dlm_user_args *ua;
5749 int error;
5750
5751 dlm_lock_recovery(ls);
5752
5753 error = find_lkb(ls, lkid, &lkb);
5754 if (error)
5755 goto out;
5756
5757 trace_dlm_unlock_start(ls, lkb, flags);
5758
5759 ua = lkb->lkb_ua;
5760
5761 if (lvb_in && ua->lksb.sb_lvbptr)
5762 memcpy(ua->lksb.sb_lvbptr, lvb_in, DLM_USER_LVB_LEN);
5763 if (ua_tmp->castparam)
5764 ua->castparam = ua_tmp->castparam;
5765 ua->user_lksb = ua_tmp->user_lksb;
5766
5767 error = set_unlock_args(flags, ua, &args);
5768 if (error)
5769 goto out_put;
5770
5771 error = unlock_lock(ls, lkb, &args);
5772
5773 if (error == -DLM_EUNLOCK)
5774 error = 0;
5775 /* from validate_unlock_args() */
5776 if (error == -EBUSY && (flags & DLM_LKF_FORCEUNLOCK))
5777 error = 0;
5778 if (error)
5779 goto out_put;
5780
5781 spin_lock(&ua->proc->locks_spin);
5782 /* dlm_user_add_cb() may have already taken lkb off the proc list */
5783 if (!list_empty(&lkb->lkb_ownqueue))
5784 list_move(&lkb->lkb_ownqueue, &ua->proc->unlocking);
5785 spin_unlock(&ua->proc->locks_spin);
5786 out_put:
5787 trace_dlm_unlock_end(ls, lkb, flags, error);
5788 dlm_put_lkb(lkb);
5789 out:
5790 dlm_unlock_recovery(ls);
5791 kfree(ua_tmp);
5792 return error;
5793}
5794
5795int dlm_user_cancel(struct dlm_ls *ls, struct dlm_user_args *ua_tmp,
5796 uint32_t flags, uint32_t lkid)
5797{
5798 struct dlm_lkb *lkb;
5799 struct dlm_args args;
5800 struct dlm_user_args *ua;
5801 int error;
5802
5803 dlm_lock_recovery(ls);
5804
5805 error = find_lkb(ls, lkid, &lkb);
5806 if (error)
5807 goto out;
5808
5809 trace_dlm_unlock_start(ls, lkb, flags);
5810
5811 ua = lkb->lkb_ua;
5812 if (ua_tmp->castparam)
5813 ua->castparam = ua_tmp->castparam;
5814 ua->user_lksb = ua_tmp->user_lksb;
5815
5816 error = set_unlock_args(flags, ua, &args);
5817 if (error)
5818 goto out_put;
5819
5820 error = cancel_lock(ls, lkb, &args);
5821
5822 if (error == -DLM_ECANCEL)
5823 error = 0;
5824 /* from validate_unlock_args() */
5825 if (error == -EBUSY)
5826 error = 0;
5827 out_put:
5828 trace_dlm_unlock_end(ls, lkb, flags, error);
5829 dlm_put_lkb(lkb);
5830 out:
5831 dlm_unlock_recovery(ls);
5832 kfree(ua_tmp);
5833 return error;
5834}
5835
5836int dlm_user_deadlock(struct dlm_ls *ls, uint32_t flags, uint32_t lkid)
5837{
5838 struct dlm_lkb *lkb;
5839 struct dlm_args args;
5840 struct dlm_user_args *ua;
5841 struct dlm_rsb *r;
5842 int error;
5843
5844 dlm_lock_recovery(ls);
5845
5846 error = find_lkb(ls, lkid, &lkb);
5847 if (error)
5848 goto out;
5849
5850 trace_dlm_unlock_start(ls, lkb, flags);
5851
5852 ua = lkb->lkb_ua;
5853
5854 error = set_unlock_args(flags, ua, &args);
5855 if (error)
5856 goto out_put;
5857
5858 /* same as cancel_lock(), but set DEADLOCK_CANCEL after lock_rsb */
5859
5860 r = lkb->lkb_resource;
5861 hold_rsb(r);
5862 lock_rsb(r);
5863
5864 error = validate_unlock_args(lkb, &args);
5865 if (error)
5866 goto out_r;
5867 set_bit(DLM_IFL_DEADLOCK_CANCEL_BIT, &lkb->lkb_iflags);
5868
5869 error = _cancel_lock(r, lkb);
5870 out_r:
5871 unlock_rsb(r);
5872 put_rsb(r);
5873
5874 if (error == -DLM_ECANCEL)
5875 error = 0;
5876 /* from validate_unlock_args() */
5877 if (error == -EBUSY)
5878 error = 0;
5879 out_put:
5880 trace_dlm_unlock_end(ls, lkb, flags, error);
5881 dlm_put_lkb(lkb);
5882 out:
5883 dlm_unlock_recovery(ls);
5884 return error;
5885}
5886
5887/* lkb's that are removed from the waiters list by revert are just left on the
5888 orphans list with the granted orphan locks, to be freed by purge */
5889
5890static int orphan_proc_lock(struct dlm_ls *ls, struct dlm_lkb *lkb)
5891{
5892 struct dlm_args args;
5893 int error;
5894
5895 hold_lkb(lkb); /* reference for the ls_orphans list */
5896 mutex_lock(&ls->ls_orphans_mutex);
5897 list_add_tail(&lkb->lkb_ownqueue, &ls->ls_orphans);
5898 mutex_unlock(&ls->ls_orphans_mutex);
5899
5900 set_unlock_args(0, lkb->lkb_ua, &args);
5901
5902 error = cancel_lock(ls, lkb, &args);
5903 if (error == -DLM_ECANCEL)
5904 error = 0;
5905 return error;
5906}
5907
5908/* The FORCEUNLOCK flag allows the unlock to go ahead even if the lkb isn't
5909 granted. Regardless of what rsb queue the lock is on, it's removed and
5910 freed. The IVVALBLK flag causes the lvb on the resource to be invalidated
5911 if our lock is PW/EX (it's ignored if our granted mode is smaller.) */
5912
5913static int unlock_proc_lock(struct dlm_ls *ls, struct dlm_lkb *lkb)
5914{
5915 struct dlm_args args;
5916 int error;
5917
5918 set_unlock_args(DLM_LKF_FORCEUNLOCK | DLM_LKF_IVVALBLK,
5919 lkb->lkb_ua, &args);
5920
5921 error = unlock_lock(ls, lkb, &args);
5922 if (error == -DLM_EUNLOCK)
5923 error = 0;
5924 return error;
5925}
5926
5927/* We have to release clear_proc_locks mutex before calling unlock_proc_lock()
5928 (which does lock_rsb) due to deadlock with receiving a message that does
5929 lock_rsb followed by dlm_user_add_cb() */
5930
5931static struct dlm_lkb *del_proc_lock(struct dlm_ls *ls,
5932 struct dlm_user_proc *proc)
5933{
5934 struct dlm_lkb *lkb = NULL;
5935
5936 spin_lock(&ls->ls_clear_proc_locks);
5937 if (list_empty(&proc->locks))
5938 goto out;
5939
5940 lkb = list_entry(proc->locks.next, struct dlm_lkb, lkb_ownqueue);
5941 list_del_init(&lkb->lkb_ownqueue);
5942
5943 if (lkb->lkb_exflags & DLM_LKF_PERSISTENT)
5944 set_bit(DLM_DFL_ORPHAN_BIT, &lkb->lkb_dflags);
5945 else
5946 set_bit(DLM_IFL_DEAD_BIT, &lkb->lkb_iflags);
5947 out:
5948 spin_unlock(&ls->ls_clear_proc_locks);
5949 return lkb;
5950}
5951
5952/* The ls_clear_proc_locks mutex protects against dlm_user_add_cb() which
5953 1) references lkb->ua which we free here and 2) adds lkbs to proc->asts,
5954 which we clear here. */
5955
5956/* proc CLOSING flag is set so no more device_reads should look at proc->asts
5957 list, and no more device_writes should add lkb's to proc->locks list; so we
5958 shouldn't need to take asts_spin or locks_spin here. this assumes that
5959 device reads/writes/closes are serialized -- FIXME: we may need to serialize
5960 them ourself. */
5961
5962void dlm_clear_proc_locks(struct dlm_ls *ls, struct dlm_user_proc *proc)
5963{
5964 struct dlm_lkb *lkb, *safe;
5965
5966 dlm_lock_recovery(ls);
5967
5968 while (1) {
5969 lkb = del_proc_lock(ls, proc);
5970 if (!lkb)
5971 break;
5972 if (lkb->lkb_exflags & DLM_LKF_PERSISTENT)
5973 orphan_proc_lock(ls, lkb);
5974 else
5975 unlock_proc_lock(ls, lkb);
5976
5977 /* this removes the reference for the proc->locks list
5978 added by dlm_user_request, it may result in the lkb
5979 being freed */
5980
5981 dlm_put_lkb(lkb);
5982 }
5983
5984 spin_lock(&ls->ls_clear_proc_locks);
5985
5986 /* in-progress unlocks */
5987 list_for_each_entry_safe(lkb, safe, &proc->unlocking, lkb_ownqueue) {
5988 list_del_init(&lkb->lkb_ownqueue);
5989 set_bit(DLM_IFL_DEAD_BIT, &lkb->lkb_iflags);
5990 dlm_put_lkb(lkb);
5991 }
5992
5993 list_for_each_entry_safe(lkb, safe, &proc->asts, lkb_cb_list) {
5994 dlm_purge_lkb_callbacks(lkb);
5995 list_del_init(&lkb->lkb_cb_list);
5996 dlm_put_lkb(lkb);
5997 }
5998
5999 spin_unlock(&ls->ls_clear_proc_locks);
6000 dlm_unlock_recovery(ls);
6001}
6002
6003static void purge_proc_locks(struct dlm_ls *ls, struct dlm_user_proc *proc)
6004{
6005 struct dlm_lkb *lkb, *safe;
6006
6007 while (1) {
6008 lkb = NULL;
6009 spin_lock(&proc->locks_spin);
6010 if (!list_empty(&proc->locks)) {
6011 lkb = list_entry(proc->locks.next, struct dlm_lkb,
6012 lkb_ownqueue);
6013 list_del_init(&lkb->lkb_ownqueue);
6014 }
6015 spin_unlock(&proc->locks_spin);
6016
6017 if (!lkb)
6018 break;
6019
6020 set_bit(DLM_IFL_DEAD_BIT, &lkb->lkb_iflags);
6021 unlock_proc_lock(ls, lkb);
6022 dlm_put_lkb(lkb); /* ref from proc->locks list */
6023 }
6024
6025 spin_lock(&proc->locks_spin);
6026 list_for_each_entry_safe(lkb, safe, &proc->unlocking, lkb_ownqueue) {
6027 list_del_init(&lkb->lkb_ownqueue);
6028 set_bit(DLM_IFL_DEAD_BIT, &lkb->lkb_iflags);
6029 dlm_put_lkb(lkb);
6030 }
6031 spin_unlock(&proc->locks_spin);
6032
6033 spin_lock(&proc->asts_spin);
6034 list_for_each_entry_safe(lkb, safe, &proc->asts, lkb_cb_list) {
6035 dlm_purge_lkb_callbacks(lkb);
6036 list_del_init(&lkb->lkb_cb_list);
6037 dlm_put_lkb(lkb);
6038 }
6039 spin_unlock(&proc->asts_spin);
6040}
6041
6042/* pid of 0 means purge all orphans */
6043
6044static void do_purge(struct dlm_ls *ls, int nodeid, int pid)
6045{
6046 struct dlm_lkb *lkb, *safe;
6047
6048 mutex_lock(&ls->ls_orphans_mutex);
6049 list_for_each_entry_safe(lkb, safe, &ls->ls_orphans, lkb_ownqueue) {
6050 if (pid && lkb->lkb_ownpid != pid)
6051 continue;
6052 unlock_proc_lock(ls, lkb);
6053 list_del_init(&lkb->lkb_ownqueue);
6054 dlm_put_lkb(lkb);
6055 }
6056 mutex_unlock(&ls->ls_orphans_mutex);
6057}
6058
6059static int send_purge(struct dlm_ls *ls, int nodeid, int pid)
6060{
6061 struct dlm_message *ms;
6062 struct dlm_mhandle *mh;
6063 int error;
6064
6065 error = _create_message(ls, sizeof(struct dlm_message), nodeid,
6066 DLM_MSG_PURGE, &ms, &mh, GFP_NOFS);
6067 if (error)
6068 return error;
6069 ms->m_nodeid = cpu_to_le32(nodeid);
6070 ms->m_pid = cpu_to_le32(pid);
6071
6072 return send_message(mh, ms, NULL, 0);
6073}
6074
6075int dlm_user_purge(struct dlm_ls *ls, struct dlm_user_proc *proc,
6076 int nodeid, int pid)
6077{
6078 int error = 0;
6079
6080 if (nodeid && (nodeid != dlm_our_nodeid())) {
6081 error = send_purge(ls, nodeid, pid);
6082 } else {
6083 dlm_lock_recovery(ls);
6084 if (pid == current->pid)
6085 purge_proc_locks(ls, proc);
6086 else
6087 do_purge(ls, nodeid, pid);
6088 dlm_unlock_recovery(ls);
6089 }
6090 return error;
6091}
6092
6093/* debug functionality */
6094int dlm_debug_add_lkb(struct dlm_ls *ls, uint32_t lkb_id, char *name, int len,
6095 int lkb_nodeid, unsigned int lkb_dflags, int lkb_status)
6096{
6097 struct dlm_lksb *lksb;
6098 struct dlm_lkb *lkb;
6099 struct dlm_rsb *r;
6100 int error;
6101
6102 /* we currently can't set a valid user lock */
6103 if (lkb_dflags & BIT(DLM_DFL_USER_BIT))
6104 return -EOPNOTSUPP;
6105
6106 lksb = kzalloc(sizeof(*lksb), GFP_NOFS);
6107 if (!lksb)
6108 return -ENOMEM;
6109
6110 error = _create_lkb(ls, &lkb, lkb_id, lkb_id + 1);
6111 if (error) {
6112 kfree(lksb);
6113 return error;
6114 }
6115
6116 dlm_set_dflags_val(lkb, lkb_dflags);
6117 lkb->lkb_nodeid = lkb_nodeid;
6118 lkb->lkb_lksb = lksb;
6119 /* user specific pointer, just don't have it NULL for kernel locks */
6120 if (~lkb_dflags & BIT(DLM_DFL_USER_BIT))
6121 lkb->lkb_astparam = (void *)0xDEADBEEF;
6122
6123 error = find_rsb(ls, name, len, 0, R_REQUEST, &r);
6124 if (error) {
6125 kfree(lksb);
6126 __put_lkb(ls, lkb);
6127 return error;
6128 }
6129
6130 lock_rsb(r);
6131 attach_lkb(r, lkb);
6132 add_lkb(r, lkb, lkb_status);
6133 unlock_rsb(r);
6134 put_rsb(r);
6135
6136 return 0;
6137}
6138
6139int dlm_debug_add_lkb_to_waiters(struct dlm_ls *ls, uint32_t lkb_id,
6140 int mstype, int to_nodeid)
6141{
6142 struct dlm_lkb *lkb;
6143 int error;
6144
6145 error = find_lkb(ls, lkb_id, &lkb);
6146 if (error)
6147 return error;
6148
6149 error = add_to_waiters(lkb, mstype, to_nodeid);
6150 dlm_put_lkb(lkb);
6151 return error;
6152}
6153