blob: a928ba008d7d7958999cdf211aa579a6ed489184 [file] [log] [blame]
David Teiglande7fd4172006-01-18 09:30:29 +00001/******************************************************************************
2*******************************************************************************
3**
David Teigland7fe2b312010-02-24 11:08:18 -06004** Copyright (C) 2005-2010 Red Hat, Inc. All rights reserved.
David Teiglande7fd4172006-01-18 09:30:29 +00005**
6** This copyrighted material is made available to anyone wishing to use,
7** modify, copy, or redistribute it subject to the terms and conditions
8** of the GNU General Public License v.2.
9**
10*******************************************************************************
11******************************************************************************/
12
13/* Central locking logic has four stages:
14
15 dlm_lock()
16 dlm_unlock()
17
18 request_lock(ls, lkb)
19 convert_lock(ls, lkb)
20 unlock_lock(ls, lkb)
21 cancel_lock(ls, lkb)
22
23 _request_lock(r, lkb)
24 _convert_lock(r, lkb)
25 _unlock_lock(r, lkb)
26 _cancel_lock(r, lkb)
27
28 do_request(r, lkb)
29 do_convert(r, lkb)
30 do_unlock(r, lkb)
31 do_cancel(r, lkb)
32
33 Stage 1 (lock, unlock) is mainly about checking input args and
34 splitting into one of the four main operations:
35
36 dlm_lock = request_lock
37 dlm_lock+CONVERT = convert_lock
38 dlm_unlock = unlock_lock
39 dlm_unlock+CANCEL = cancel_lock
40
41 Stage 2, xxxx_lock(), just finds and locks the relevant rsb which is
42 provided to the next stage.
43
44 Stage 3, _xxxx_lock(), determines if the operation is local or remote.
45 When remote, it calls send_xxxx(), when local it calls do_xxxx().
46
47 Stage 4, do_xxxx(), is the guts of the operation. It manipulates the
48 given rsb and lkb and queues callbacks.
49
50 For remote operations, send_xxxx() results in the corresponding do_xxxx()
51 function being executed on the remote node. The connecting send/receive
52 calls on local (L) and remote (R) nodes:
53
54 L: send_xxxx() -> R: receive_xxxx()
55 R: do_xxxx()
56 L: receive_xxxx_reply() <- R: send_xxxx_reply()
57*/
David Teigland597d0ca2006-07-12 16:44:04 -050058#include <linux/types.h>
Bob Peterson9beb3bf2011-10-26 15:24:55 -050059#include <linux/rbtree.h>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090060#include <linux/slab.h>
David Teiglande7fd4172006-01-18 09:30:29 +000061#include "dlm_internal.h"
David Teigland597d0ca2006-07-12 16:44:04 -050062#include <linux/dlm_device.h>
David Teiglande7fd4172006-01-18 09:30:29 +000063#include "memory.h"
64#include "lowcomms.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"
David Teigland597d0ca2006-07-12 16:44:04 -050075#include "user.h"
David Teiglande7fd4172006-01-18 09:30:29 +000076#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);
David Teigland3ae1acf2007-05-18 08:59:31 -050087static int _cancel_lock(struct dlm_rsb *r, struct dlm_lkb *lkb);
David Teiglande7fd4172006-01-18 09:30:29 +000088static void __receive_convert_reply(struct dlm_rsb *r, struct dlm_lkb *lkb,
89 struct dlm_message *ms);
90static int receive_extralen(struct dlm_message *ms);
David Teigland84991372007-03-30 15:02:40 -050091static void do_purge(struct dlm_ls *ls, int nodeid, int pid);
David Teigland3ae1acf2007-05-18 08:59:31 -050092static void del_timeout(struct dlm_lkb *lkb);
David Teiglandc04fecb2012-05-10 10:18:07 -050093static void toss_rsb(struct kref *kref);
David Teiglande7fd4172006-01-18 09:30:29 +000094
95/*
96 * Lock compatibilty matrix - thanks Steve
97 * UN = Unlocked state. Not really a state, used as a flag
98 * PD = Padding. Used to make the matrix a nice power of two in size
99 * Other states are the same as the VMS DLM.
100 * Usage: matrix[grmode+1][rqmode+1] (although m[rq+1][gr+1] is the same)
101 */
102
103static const int __dlm_compat_matrix[8][8] = {
104 /* UN NL CR CW PR PW EX PD */
105 {1, 1, 1, 1, 1, 1, 1, 0}, /* UN */
106 {1, 1, 1, 1, 1, 1, 1, 0}, /* NL */
107 {1, 1, 1, 1, 1, 1, 0, 0}, /* CR */
108 {1, 1, 1, 1, 0, 0, 0, 0}, /* CW */
109 {1, 1, 1, 0, 1, 0, 0, 0}, /* PR */
110 {1, 1, 1, 0, 0, 0, 0, 0}, /* PW */
111 {1, 1, 0, 0, 0, 0, 0, 0}, /* EX */
112 {0, 0, 0, 0, 0, 0, 0, 0} /* PD */
113};
114
115/*
116 * This defines the direction of transfer of LVB data.
117 * Granted mode is the row; requested mode is the column.
118 * Usage: matrix[grmode+1][rqmode+1]
119 * 1 = LVB is returned to the caller
120 * 0 = LVB is written to the resource
121 * -1 = nothing happens to the LVB
122 */
123
124const int dlm_lvb_operations[8][8] = {
125 /* UN NL CR CW PR PW EX PD*/
126 { -1, 1, 1, 1, 1, 1, 1, -1 }, /* UN */
127 { -1, 1, 1, 1, 1, 1, 1, 0 }, /* NL */
128 { -1, -1, 1, 1, 1, 1, 1, 0 }, /* CR */
129 { -1, -1, -1, 1, 1, 1, 1, 0 }, /* CW */
130 { -1, -1, -1, -1, 1, 1, 1, 0 }, /* PR */
131 { -1, 0, 0, 0, 0, 0, 1, 0 }, /* PW */
132 { -1, 0, 0, 0, 0, 0, 0, 0 }, /* EX */
133 { -1, 0, 0, 0, 0, 0, 0, 0 } /* PD */
134};
David Teiglande7fd4172006-01-18 09:30:29 +0000135
136#define modes_compat(gr, rq) \
137 __dlm_compat_matrix[(gr)->lkb_grmode + 1][(rq)->lkb_rqmode + 1]
138
139int dlm_modes_compat(int mode1, int mode2)
140{
141 return __dlm_compat_matrix[mode1 + 1][mode2 + 1];
142}
143
144/*
145 * Compatibility matrix for conversions with QUECVT set.
146 * Granted mode is the row; requested mode is the column.
147 * Usage: matrix[grmode+1][rqmode+1]
148 */
149
150static const int __quecvt_compat_matrix[8][8] = {
151 /* UN NL CR CW PR PW EX PD */
152 {0, 0, 0, 0, 0, 0, 0, 0}, /* UN */
153 {0, 0, 1, 1, 1, 1, 1, 0}, /* NL */
154 {0, 0, 0, 1, 1, 1, 1, 0}, /* CR */
155 {0, 0, 0, 0, 1, 1, 1, 0}, /* CW */
156 {0, 0, 0, 1, 0, 1, 1, 0}, /* PR */
157 {0, 0, 0, 0, 0, 0, 1, 0}, /* PW */
158 {0, 0, 0, 0, 0, 0, 0, 0}, /* EX */
159 {0, 0, 0, 0, 0, 0, 0, 0} /* PD */
160};
161
David Teigland597d0ca2006-07-12 16:44:04 -0500162void dlm_print_lkb(struct dlm_lkb *lkb)
David Teiglande7fd4172006-01-18 09:30:29 +0000163{
David Teigland6d40c4a2012-04-23 16:36:01 -0500164 printk(KERN_ERR "lkb: nodeid %d id %x remid %x exflags %x flags %x "
David Teigland48756472012-04-26 15:54:29 -0500165 "sts %d rq %d gr %d wait_type %d wait_nodeid %d seq %llu\n",
David Teiglande7fd4172006-01-18 09:30:29 +0000166 lkb->lkb_nodeid, lkb->lkb_id, lkb->lkb_remid, lkb->lkb_exflags,
167 lkb->lkb_flags, lkb->lkb_status, lkb->lkb_rqmode,
David Teigland48756472012-04-26 15:54:29 -0500168 lkb->lkb_grmode, lkb->lkb_wait_type, lkb->lkb_wait_nodeid,
169 (unsigned long long)lkb->lkb_recover_seq);
David Teiglande7fd4172006-01-18 09:30:29 +0000170}
171
Adrian Bunk170e19a2008-02-13 23:29:38 +0200172static void dlm_print_rsb(struct dlm_rsb *r)
David Teiglande7fd4172006-01-18 09:30:29 +0000173{
David Teiglandc04fecb2012-05-10 10:18:07 -0500174 printk(KERN_ERR "rsb: nodeid %d master %d dir %d flags %lx first %x "
175 "rlc %d name %s\n",
176 r->res_nodeid, r->res_master_nodeid, r->res_dir_nodeid,
177 r->res_flags, r->res_first_lkid, r->res_recover_locks_count,
178 r->res_name);
David Teiglande7fd4172006-01-18 09:30:29 +0000179}
180
David Teiglanda345da32006-08-18 11:54:25 -0500181void dlm_dump_rsb(struct dlm_rsb *r)
182{
183 struct dlm_lkb *lkb;
184
185 dlm_print_rsb(r);
186
187 printk(KERN_ERR "rsb: root_list empty %d recover_list empty %d\n",
188 list_empty(&r->res_root_list), list_empty(&r->res_recover_list));
189 printk(KERN_ERR "rsb lookup list\n");
190 list_for_each_entry(lkb, &r->res_lookup, lkb_rsb_lookup)
191 dlm_print_lkb(lkb);
192 printk(KERN_ERR "rsb grant queue:\n");
193 list_for_each_entry(lkb, &r->res_grantqueue, lkb_statequeue)
194 dlm_print_lkb(lkb);
195 printk(KERN_ERR "rsb convert queue:\n");
196 list_for_each_entry(lkb, &r->res_convertqueue, lkb_statequeue)
197 dlm_print_lkb(lkb);
198 printk(KERN_ERR "rsb wait queue:\n");
199 list_for_each_entry(lkb, &r->res_waitqueue, lkb_statequeue)
200 dlm_print_lkb(lkb);
201}
202
David Teiglande7fd4172006-01-18 09:30:29 +0000203/* Threads cannot use the lockspace while it's being recovered */
204
David Teigland85e86ed2007-05-18 08:58:15 -0500205static inline void dlm_lock_recovery(struct dlm_ls *ls)
David Teiglande7fd4172006-01-18 09:30:29 +0000206{
207 down_read(&ls->ls_in_recovery);
208}
209
David Teigland85e86ed2007-05-18 08:58:15 -0500210void dlm_unlock_recovery(struct dlm_ls *ls)
David Teiglande7fd4172006-01-18 09:30:29 +0000211{
212 up_read(&ls->ls_in_recovery);
213}
214
David Teigland85e86ed2007-05-18 08:58:15 -0500215int dlm_lock_recovery_try(struct dlm_ls *ls)
David Teiglande7fd4172006-01-18 09:30:29 +0000216{
217 return down_read_trylock(&ls->ls_in_recovery);
218}
219
220static inline int can_be_queued(struct dlm_lkb *lkb)
221{
222 return !(lkb->lkb_exflags & DLM_LKF_NOQUEUE);
223}
224
225static inline int force_blocking_asts(struct dlm_lkb *lkb)
226{
227 return (lkb->lkb_exflags & DLM_LKF_NOQUEUEBAST);
228}
229
230static inline int is_demoted(struct dlm_lkb *lkb)
231{
232 return (lkb->lkb_sbflags & DLM_SBF_DEMOTED);
233}
234
David Teigland7d3c1fe2007-04-19 10:30:41 -0500235static inline int is_altmode(struct dlm_lkb *lkb)
236{
237 return (lkb->lkb_sbflags & DLM_SBF_ALTMODE);
238}
239
240static inline int is_granted(struct dlm_lkb *lkb)
241{
242 return (lkb->lkb_status == DLM_LKSTS_GRANTED);
243}
244
David Teiglande7fd4172006-01-18 09:30:29 +0000245static inline int is_remote(struct dlm_rsb *r)
246{
247 DLM_ASSERT(r->res_nodeid >= 0, dlm_print_rsb(r););
248 return !!r->res_nodeid;
249}
250
251static inline int is_process_copy(struct dlm_lkb *lkb)
252{
253 return (lkb->lkb_nodeid && !(lkb->lkb_flags & DLM_IFL_MSTCPY));
254}
255
256static inline int is_master_copy(struct dlm_lkb *lkb)
257{
David Teigland90135922006-01-20 08:47:07 +0000258 return (lkb->lkb_flags & DLM_IFL_MSTCPY) ? 1 : 0;
David Teiglande7fd4172006-01-18 09:30:29 +0000259}
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))
David Teigland90135922006-01-20 08:47:07 +0000265 return 1;
266 return 0;
David Teiglande7fd4172006-01-18 09:30:29 +0000267}
268
269static inline int down_conversion(struct dlm_lkb *lkb)
270{
271 return (!middle_conversion(lkb) && lkb->lkb_rqmode < lkb->lkb_grmode);
272}
273
David Teiglandef0c2bb2007-03-28 09:56:46 -0500274static inline int is_overlap_unlock(struct dlm_lkb *lkb)
275{
276 return lkb->lkb_flags & DLM_IFL_OVERLAP_UNLOCK;
277}
278
279static inline int is_overlap_cancel(struct dlm_lkb *lkb)
280{
281 return lkb->lkb_flags & DLM_IFL_OVERLAP_CANCEL;
282}
283
284static inline int is_overlap(struct dlm_lkb *lkb)
285{
286 return (lkb->lkb_flags & (DLM_IFL_OVERLAP_UNLOCK |
287 DLM_IFL_OVERLAP_CANCEL));
288}
289
David Teiglande7fd4172006-01-18 09:30:29 +0000290static void queue_cast(struct dlm_rsb *r, struct dlm_lkb *lkb, int rv)
291{
292 if (is_master_copy(lkb))
293 return;
294
David Teigland3ae1acf2007-05-18 08:59:31 -0500295 del_timeout(lkb);
296
David Teiglande7fd4172006-01-18 09:30:29 +0000297 DLM_ASSERT(lkb->lkb_lksb, dlm_print_lkb(lkb););
298
David Teigland3ae1acf2007-05-18 08:59:31 -0500299 /* if the operation was a cancel, then return -DLM_ECANCEL, if a
300 timeout caused the cancel then return -ETIMEDOUT */
301 if (rv == -DLM_ECANCEL && (lkb->lkb_flags & DLM_IFL_TIMEOUT_CANCEL)) {
302 lkb->lkb_flags &= ~DLM_IFL_TIMEOUT_CANCEL;
303 rv = -ETIMEDOUT;
304 }
305
David Teigland8b4021f2007-05-29 08:46:00 -0500306 if (rv == -DLM_ECANCEL && (lkb->lkb_flags & DLM_IFL_DEADLOCK_CANCEL)) {
307 lkb->lkb_flags &= ~DLM_IFL_DEADLOCK_CANCEL;
308 rv = -EDEADLK;
309 }
310
David Teigland23e8e1a2011-04-05 13:16:24 -0500311 dlm_add_cb(lkb, DLM_CB_CAST, lkb->lkb_grmode, rv, lkb->lkb_sbflags);
David Teiglande7fd4172006-01-18 09:30:29 +0000312}
313
David Teiglandef0c2bb2007-03-28 09:56:46 -0500314static inline void queue_cast_overlap(struct dlm_rsb *r, struct dlm_lkb *lkb)
315{
316 queue_cast(r, lkb,
317 is_overlap_unlock(lkb) ? -DLM_EUNLOCK : -DLM_ECANCEL);
318}
319
David Teiglande7fd4172006-01-18 09:30:29 +0000320static void queue_bast(struct dlm_rsb *r, struct dlm_lkb *lkb, int rqmode)
321{
David Teiglandb6fa8792010-02-25 12:20:57 -0600322 if (is_master_copy(lkb)) {
David Teiglande7fd4172006-01-18 09:30:29 +0000323 send_bast(r, lkb, rqmode);
David Teiglandb6fa8792010-02-25 12:20:57 -0600324 } else {
David Teigland23e8e1a2011-04-05 13:16:24 -0500325 dlm_add_cb(lkb, DLM_CB_BAST, rqmode, 0, 0);
David Teiglandb6fa8792010-02-25 12:20:57 -0600326 }
David Teiglande7fd4172006-01-18 09:30:29 +0000327}
328
329/*
330 * Basic operations on rsb's and lkb's
331 */
332
David Teiglandc04fecb2012-05-10 10:18:07 -0500333/* This is only called to add a reference when the code already holds
334 a valid reference to the rsb, so there's no need for locking. */
335
336static inline void hold_rsb(struct dlm_rsb *r)
337{
338 kref_get(&r->res_ref);
339}
340
341void dlm_hold_rsb(struct dlm_rsb *r)
342{
343 hold_rsb(r);
344}
345
346/* When all references to the rsb are gone it's transferred to
347 the tossed list for later disposal. */
348
349static void put_rsb(struct dlm_rsb *r)
350{
351 struct dlm_ls *ls = r->res_ls;
352 uint32_t bucket = r->res_bucket;
353
354 spin_lock(&ls->ls_rsbtbl[bucket].lock);
355 kref_put(&r->res_ref, toss_rsb);
356 spin_unlock(&ls->ls_rsbtbl[bucket].lock);
357}
358
359void dlm_put_rsb(struct dlm_rsb *r)
360{
361 put_rsb(r);
362}
363
David Teigland3881ac02011-07-07 14:05:03 -0500364static int pre_rsb_struct(struct dlm_ls *ls)
365{
366 struct dlm_rsb *r1, *r2;
367 int count = 0;
368
369 spin_lock(&ls->ls_new_rsb_spin);
370 if (ls->ls_new_rsb_count > dlm_config.ci_new_rsb_count / 2) {
371 spin_unlock(&ls->ls_new_rsb_spin);
372 return 0;
373 }
374 spin_unlock(&ls->ls_new_rsb_spin);
375
376 r1 = dlm_allocate_rsb(ls);
377 r2 = dlm_allocate_rsb(ls);
378
379 spin_lock(&ls->ls_new_rsb_spin);
380 if (r1) {
381 list_add(&r1->res_hashchain, &ls->ls_new_rsb);
382 ls->ls_new_rsb_count++;
383 }
384 if (r2) {
385 list_add(&r2->res_hashchain, &ls->ls_new_rsb);
386 ls->ls_new_rsb_count++;
387 }
388 count = ls->ls_new_rsb_count;
389 spin_unlock(&ls->ls_new_rsb_spin);
390
391 if (!count)
392 return -ENOMEM;
393 return 0;
394}
395
396/* If ls->ls_new_rsb is empty, return -EAGAIN, so the caller can
397 unlock any spinlocks, go back and call pre_rsb_struct again.
398 Otherwise, take an rsb off the list and return it. */
399
400static int get_rsb_struct(struct dlm_ls *ls, char *name, int len,
401 struct dlm_rsb **r_ret)
David Teiglande7fd4172006-01-18 09:30:29 +0000402{
403 struct dlm_rsb *r;
David Teigland3881ac02011-07-07 14:05:03 -0500404 int count;
David Teiglande7fd4172006-01-18 09:30:29 +0000405
David Teigland3881ac02011-07-07 14:05:03 -0500406 spin_lock(&ls->ls_new_rsb_spin);
407 if (list_empty(&ls->ls_new_rsb)) {
408 count = ls->ls_new_rsb_count;
409 spin_unlock(&ls->ls_new_rsb_spin);
410 log_debug(ls, "find_rsb retry %d %d %s",
411 count, dlm_config.ci_new_rsb_count, name);
412 return -EAGAIN;
413 }
414
415 r = list_first_entry(&ls->ls_new_rsb, struct dlm_rsb, res_hashchain);
416 list_del(&r->res_hashchain);
Bob Peterson9beb3bf2011-10-26 15:24:55 -0500417 /* Convert the empty list_head to a NULL rb_node for tree usage: */
418 memset(&r->res_hashnode, 0, sizeof(struct rb_node));
David Teigland3881ac02011-07-07 14:05:03 -0500419 ls->ls_new_rsb_count--;
420 spin_unlock(&ls->ls_new_rsb_spin);
David Teiglande7fd4172006-01-18 09:30:29 +0000421
422 r->res_ls = ls;
423 r->res_length = len;
424 memcpy(r->res_name, name, len);
David Teigland90135922006-01-20 08:47:07 +0000425 mutex_init(&r->res_mutex);
David Teiglande7fd4172006-01-18 09:30:29 +0000426
427 INIT_LIST_HEAD(&r->res_lookup);
428 INIT_LIST_HEAD(&r->res_grantqueue);
429 INIT_LIST_HEAD(&r->res_convertqueue);
430 INIT_LIST_HEAD(&r->res_waitqueue);
431 INIT_LIST_HEAD(&r->res_root_list);
432 INIT_LIST_HEAD(&r->res_recover_list);
433
David Teigland3881ac02011-07-07 14:05:03 -0500434 *r_ret = r;
435 return 0;
David Teiglande7fd4172006-01-18 09:30:29 +0000436}
437
Bob Peterson9beb3bf2011-10-26 15:24:55 -0500438static int rsb_cmp(struct dlm_rsb *r, const char *name, int nlen)
439{
440 char maxname[DLM_RESNAME_MAXLEN];
441
442 memset(maxname, 0, DLM_RESNAME_MAXLEN);
443 memcpy(maxname, name, nlen);
444 return memcmp(r->res_name, maxname, DLM_RESNAME_MAXLEN);
445}
446
David Teigland7210cb72012-03-08 12:37:12 -0600447int dlm_search_rsb_tree(struct rb_root *tree, char *name, int len,
David Teiglandc04fecb2012-05-10 10:18:07 -0500448 struct dlm_rsb **r_ret)
David Teiglande7fd4172006-01-18 09:30:29 +0000449{
Bob Peterson9beb3bf2011-10-26 15:24:55 -0500450 struct rb_node *node = tree->rb_node;
David Teiglande7fd4172006-01-18 09:30:29 +0000451 struct dlm_rsb *r;
Bob Peterson9beb3bf2011-10-26 15:24:55 -0500452 int rc;
David Teiglande7fd4172006-01-18 09:30:29 +0000453
Bob Peterson9beb3bf2011-10-26 15:24:55 -0500454 while (node) {
455 r = rb_entry(node, struct dlm_rsb, res_hashnode);
456 rc = rsb_cmp(r, name, len);
457 if (rc < 0)
458 node = node->rb_left;
459 else if (rc > 0)
460 node = node->rb_right;
461 else
David Teiglande7fd4172006-01-18 09:30:29 +0000462 goto found;
463 }
Benny Halevy18c60c02008-06-30 19:59:14 +0300464 *r_ret = NULL;
David Teigland597d0ca2006-07-12 16:44:04 -0500465 return -EBADR;
David Teiglande7fd4172006-01-18 09:30:29 +0000466
467 found:
David Teiglande7fd4172006-01-18 09:30:29 +0000468 *r_ret = r;
David Teiglandc04fecb2012-05-10 10:18:07 -0500469 return 0;
David Teiglande7fd4172006-01-18 09:30:29 +0000470}
471
Bob Peterson9beb3bf2011-10-26 15:24:55 -0500472static int rsb_insert(struct dlm_rsb *rsb, struct rb_root *tree)
473{
474 struct rb_node **newn = &tree->rb_node;
475 struct rb_node *parent = NULL;
476 int rc;
477
478 while (*newn) {
479 struct dlm_rsb *cur = rb_entry(*newn, struct dlm_rsb,
480 res_hashnode);
481
482 parent = *newn;
483 rc = rsb_cmp(cur, rsb->res_name, rsb->res_length);
484 if (rc < 0)
485 newn = &parent->rb_left;
486 else if (rc > 0)
487 newn = &parent->rb_right;
488 else {
489 log_print("rsb_insert match");
490 dlm_dump_rsb(rsb);
491 dlm_dump_rsb(cur);
492 return -EEXIST;
493 }
494 }
495
496 rb_link_node(&rsb->res_hashnode, parent, newn);
497 rb_insert_color(&rsb->res_hashnode, tree);
498 return 0;
499}
500
David Teiglande7fd4172006-01-18 09:30:29 +0000501/*
502 * Find rsb in rsbtbl and potentially create/add one
503 *
504 * Delaying the release of rsb's has a similar benefit to applications keeping
505 * NL locks on an rsb, but without the guarantee that the cached master value
506 * will still be valid when the rsb is reused. Apps aren't always smart enough
507 * to keep NL locks on an rsb that they may lock again shortly; this can lead
508 * to excessive master lookups and removals if we don't delay the release.
509 *
510 * Searching for an rsb means looking through both the normal list and toss
511 * list. When found on the toss list the rsb is moved to the normal list with
512 * ref count of 1; when found on normal list the ref count is incremented.
David Teiglandc04fecb2012-05-10 10:18:07 -0500513 *
514 * rsb's on the keep list are being used locally and refcounted.
515 * rsb's on the toss list are not being used locally, and are not refcounted.
516 *
517 * The toss list rsb's were either
518 * - previously used locally but not any more (were on keep list, then
519 * moved to toss list when last refcount dropped)
520 * - created and put on toss list as a directory record for a lookup
521 * (we are the dir node for the res, but are not using the res right now,
522 * but some other node is)
523 *
524 * The purpose of find_rsb() is to return a refcounted rsb for local use.
525 * So, if the given rsb is on the toss list, it is moved to the keep list
526 * before being returned.
527 *
528 * toss_rsb() happens when all local usage of the rsb is done, i.e. no
529 * more refcounts exist, so the rsb is moved from the keep list to the
530 * toss list.
531 *
532 * rsb's on both keep and toss lists are used for doing a name to master
533 * lookups. rsb's that are in use locally (and being refcounted) are on
534 * the keep list, rsb's that are not in use locally (not refcounted) and
535 * only exist for name/master lookups are on the toss list.
536 *
537 * rsb's on the toss list who's dir_nodeid is not local can have stale
538 * name/master mappings. So, remote requests on such rsb's can potentially
539 * return with an error, which means the mapping is stale and needs to
540 * be updated with a new lookup. (The idea behind MASTER UNCERTAIN and
541 * first_lkid is to keep only a single outstanding request on an rsb
542 * while that rsb has a potentially stale master.)
David Teiglande7fd4172006-01-18 09:30:29 +0000543 */
544
David Teiglandc04fecb2012-05-10 10:18:07 -0500545static int find_rsb_dir(struct dlm_ls *ls, char *name, int len,
546 uint32_t hash, uint32_t b,
547 int dir_nodeid, int from_nodeid,
548 unsigned int flags, struct dlm_rsb **r_ret)
David Teiglande7fd4172006-01-18 09:30:29 +0000549{
David Teigland3881ac02011-07-07 14:05:03 -0500550 struct dlm_rsb *r = NULL;
David Teiglandc04fecb2012-05-10 10:18:07 -0500551 int our_nodeid = dlm_our_nodeid();
552 int from_local = 0;
553 int from_other = 0;
554 int from_dir = 0;
555 int create = 0;
David Teigland3881ac02011-07-07 14:05:03 -0500556 int error;
Al Viroef58bcc2008-01-25 23:22:26 -0500557
David Teiglandc04fecb2012-05-10 10:18:07 -0500558 if (flags & R_RECEIVE_REQUEST) {
559 if (from_nodeid == dir_nodeid)
560 from_dir = 1;
561 else
562 from_other = 1;
563 } else if (flags & R_REQUEST) {
564 from_local = 1;
David Teigland3881ac02011-07-07 14:05:03 -0500565 }
David Teiglande7fd4172006-01-18 09:30:29 +0000566
David Teiglandc04fecb2012-05-10 10:18:07 -0500567 /*
568 * flags & R_RECEIVE_RECOVER is from dlm_recover_master_copy, so
569 * from_nodeid has sent us a lock in dlm_recover_locks, believing
570 * we're the new master. Our local recovery may not have set
571 * res_master_nodeid to our_nodeid yet, so allow either. Don't
572 * create the rsb; dlm_recover_process_copy() will handle EBADR
573 * by resending.
574 *
575 * If someone sends us a request, we are the dir node, and we do
576 * not find the rsb anywhere, then recreate it. This happens if
577 * someone sends us a request after we have removed/freed an rsb
578 * from our toss list. (They sent a request instead of lookup
579 * because they are using an rsb from their toss list.)
580 */
David Teiglande7fd4172006-01-18 09:30:29 +0000581
David Teiglandc04fecb2012-05-10 10:18:07 -0500582 if (from_local || from_dir ||
583 (from_other && (dir_nodeid == our_nodeid))) {
584 create = 1;
585 }
David Teiglande7fd4172006-01-18 09:30:29 +0000586
David Teigland3881ac02011-07-07 14:05:03 -0500587 retry:
David Teiglandc04fecb2012-05-10 10:18:07 -0500588 if (create) {
David Teigland3881ac02011-07-07 14:05:03 -0500589 error = pre_rsb_struct(ls);
590 if (error < 0)
591 goto out;
592 }
593
David Teiglandc04fecb2012-05-10 10:18:07 -0500594 spin_lock(&ls->ls_rsbtbl[b].lock);
David Teigland3881ac02011-07-07 14:05:03 -0500595
David Teiglandc04fecb2012-05-10 10:18:07 -0500596 error = dlm_search_rsb_tree(&ls->ls_rsbtbl[b].keep, name, len, &r);
597 if (error)
598 goto do_toss;
599
600 /*
601 * rsb is active, so we can't check master_nodeid without lock_rsb.
602 */
603
604 kref_get(&r->res_ref);
605 error = 0;
606 goto out_unlock;
607
608
609 do_toss:
610 error = dlm_search_rsb_tree(&ls->ls_rsbtbl[b].toss, name, len, &r);
611 if (error)
612 goto do_new;
613
614 /*
615 * rsb found inactive (master_nodeid may be out of date unless
616 * we are the dir_nodeid or were the master) No other thread
617 * is using this rsb because it's on the toss list, so we can
618 * look at or update res_master_nodeid without lock_rsb.
619 */
620
621 if ((r->res_master_nodeid != our_nodeid) && from_other) {
622 /* our rsb was not master, and another node (not the dir node)
623 has sent us a request */
624 log_debug(ls, "find_rsb toss from_other %d master %d dir %d %s",
625 from_nodeid, r->res_master_nodeid, dir_nodeid,
626 r->res_name);
627 error = -ENOTBLK;
628 goto out_unlock;
629 }
630
631 if ((r->res_master_nodeid != our_nodeid) && from_dir) {
632 /* don't think this should ever happen */
633 log_error(ls, "find_rsb toss from_dir %d master %d",
634 from_nodeid, r->res_master_nodeid);
635 dlm_print_rsb(r);
636 /* fix it and go on */
637 r->res_master_nodeid = our_nodeid;
638 r->res_nodeid = 0;
639 rsb_clear_flag(r, RSB_MASTER_UNCERTAIN);
640 r->res_first_lkid = 0;
641 }
642
643 if (from_local && (r->res_master_nodeid != our_nodeid)) {
644 /* Because we have held no locks on this rsb,
645 res_master_nodeid could have become stale. */
646 rsb_set_flag(r, RSB_MASTER_UNCERTAIN);
647 r->res_first_lkid = 0;
648 }
649
650 rb_erase(&r->res_hashnode, &ls->ls_rsbtbl[b].toss);
651 error = rsb_insert(r, &ls->ls_rsbtbl[b].keep);
652 goto out_unlock;
653
654
655 do_new:
656 /*
657 * rsb not found
658 */
659
660 if (error == -EBADR && !create)
David Teigland3881ac02011-07-07 14:05:03 -0500661 goto out_unlock;
David Teiglande7fd4172006-01-18 09:30:29 +0000662
David Teiglandc04fecb2012-05-10 10:18:07 -0500663 error = get_rsb_struct(ls, name, len, &r);
David Teigland3881ac02011-07-07 14:05:03 -0500664 if (error == -EAGAIN) {
David Teiglandc04fecb2012-05-10 10:18:07 -0500665 spin_unlock(&ls->ls_rsbtbl[b].lock);
David Teigland3881ac02011-07-07 14:05:03 -0500666 goto retry;
667 }
668 if (error)
669 goto out_unlock;
David Teiglande7fd4172006-01-18 09:30:29 +0000670
671 r->res_hash = hash;
David Teiglandc04fecb2012-05-10 10:18:07 -0500672 r->res_bucket = b;
673 r->res_dir_nodeid = dir_nodeid;
David Teiglande7fd4172006-01-18 09:30:29 +0000674 kref_init(&r->res_ref);
675
David Teiglandc04fecb2012-05-10 10:18:07 -0500676 if (from_dir) {
677 /* want to see how often this happens */
678 log_debug(ls, "find_rsb new from_dir %d recreate %s",
679 from_nodeid, r->res_name);
680 r->res_master_nodeid = our_nodeid;
681 r->res_nodeid = 0;
682 goto out_add;
David Teiglande7fd4172006-01-18 09:30:29 +0000683 }
David Teiglandc04fecb2012-05-10 10:18:07 -0500684
685 if (from_other && (dir_nodeid != our_nodeid)) {
686 /* should never happen */
687 log_error(ls, "find_rsb new from_other %d dir %d our %d %s",
688 from_nodeid, dir_nodeid, our_nodeid, r->res_name);
689 dlm_free_rsb(r);
Dan Carpentere8243f32014-02-05 16:21:53 +0300690 r = NULL;
David Teiglandc04fecb2012-05-10 10:18:07 -0500691 error = -ENOTBLK;
692 goto out_unlock;
693 }
694
695 if (from_other) {
696 log_debug(ls, "find_rsb new from_other %d dir %d %s",
697 from_nodeid, dir_nodeid, r->res_name);
698 }
699
700 if (dir_nodeid == our_nodeid) {
701 /* When we are the dir nodeid, we can set the master
702 node immediately */
703 r->res_master_nodeid = our_nodeid;
704 r->res_nodeid = 0;
705 } else {
706 /* set_master will send_lookup to dir_nodeid */
707 r->res_master_nodeid = 0;
708 r->res_nodeid = -1;
709 }
710
711 out_add:
712 error = rsb_insert(r, &ls->ls_rsbtbl[b].keep);
David Teigland3881ac02011-07-07 14:05:03 -0500713 out_unlock:
David Teiglandc04fecb2012-05-10 10:18:07 -0500714 spin_unlock(&ls->ls_rsbtbl[b].lock);
David Teiglande7fd4172006-01-18 09:30:29 +0000715 out:
716 *r_ret = r;
717 return error;
718}
719
David Teiglandc04fecb2012-05-10 10:18:07 -0500720/* During recovery, other nodes can send us new MSTCPY locks (from
721 dlm_recover_locks) before we've made ourself master (in
722 dlm_recover_masters). */
723
724static int find_rsb_nodir(struct dlm_ls *ls, char *name, int len,
725 uint32_t hash, uint32_t b,
726 int dir_nodeid, int from_nodeid,
727 unsigned int flags, struct dlm_rsb **r_ret)
728{
729 struct dlm_rsb *r = NULL;
730 int our_nodeid = dlm_our_nodeid();
731 int recover = (flags & R_RECEIVE_RECOVER);
732 int error;
733
734 retry:
735 error = pre_rsb_struct(ls);
736 if (error < 0)
737 goto out;
738
739 spin_lock(&ls->ls_rsbtbl[b].lock);
740
741 error = dlm_search_rsb_tree(&ls->ls_rsbtbl[b].keep, name, len, &r);
742 if (error)
743 goto do_toss;
744
745 /*
746 * rsb is active, so we can't check master_nodeid without lock_rsb.
747 */
748
749 kref_get(&r->res_ref);
750 goto out_unlock;
751
752
753 do_toss:
754 error = dlm_search_rsb_tree(&ls->ls_rsbtbl[b].toss, name, len, &r);
755 if (error)
756 goto do_new;
757
758 /*
759 * rsb found inactive. No other thread is using this rsb because
760 * it's on the toss list, so we can look at or update
761 * res_master_nodeid without lock_rsb.
762 */
763
764 if (!recover && (r->res_master_nodeid != our_nodeid) && from_nodeid) {
765 /* our rsb is not master, and another node has sent us a
766 request; this should never happen */
767 log_error(ls, "find_rsb toss from_nodeid %d master %d dir %d",
768 from_nodeid, r->res_master_nodeid, dir_nodeid);
769 dlm_print_rsb(r);
770 error = -ENOTBLK;
771 goto out_unlock;
772 }
773
774 if (!recover && (r->res_master_nodeid != our_nodeid) &&
775 (dir_nodeid == our_nodeid)) {
776 /* our rsb is not master, and we are dir; may as well fix it;
777 this should never happen */
778 log_error(ls, "find_rsb toss our %d master %d dir %d",
779 our_nodeid, r->res_master_nodeid, dir_nodeid);
780 dlm_print_rsb(r);
781 r->res_master_nodeid = our_nodeid;
782 r->res_nodeid = 0;
783 }
784
785 rb_erase(&r->res_hashnode, &ls->ls_rsbtbl[b].toss);
786 error = rsb_insert(r, &ls->ls_rsbtbl[b].keep);
787 goto out_unlock;
788
789
790 do_new:
791 /*
792 * rsb not found
793 */
794
795 error = get_rsb_struct(ls, name, len, &r);
796 if (error == -EAGAIN) {
797 spin_unlock(&ls->ls_rsbtbl[b].lock);
798 goto retry;
799 }
800 if (error)
801 goto out_unlock;
802
803 r->res_hash = hash;
804 r->res_bucket = b;
805 r->res_dir_nodeid = dir_nodeid;
806 r->res_master_nodeid = dir_nodeid;
807 r->res_nodeid = (dir_nodeid == our_nodeid) ? 0 : dir_nodeid;
808 kref_init(&r->res_ref);
809
810 error = rsb_insert(r, &ls->ls_rsbtbl[b].keep);
811 out_unlock:
812 spin_unlock(&ls->ls_rsbtbl[b].lock);
813 out:
814 *r_ret = r;
815 return error;
816}
817
818static int find_rsb(struct dlm_ls *ls, char *name, int len, int from_nodeid,
819 unsigned int flags, struct dlm_rsb **r_ret)
820{
821 uint32_t hash, b;
822 int dir_nodeid;
823
824 if (len > DLM_RESNAME_MAXLEN)
825 return -EINVAL;
826
827 hash = jhash(name, len, 0);
828 b = hash & (ls->ls_rsbtbl_size - 1);
829
830 dir_nodeid = dlm_hash2nodeid(ls, hash);
831
832 if (dlm_no_directory(ls))
833 return find_rsb_nodir(ls, name, len, hash, b, dir_nodeid,
834 from_nodeid, flags, r_ret);
835 else
836 return find_rsb_dir(ls, name, len, hash, b, dir_nodeid,
837 from_nodeid, flags, r_ret);
838}
839
840/* we have received a request and found that res_master_nodeid != our_nodeid,
841 so we need to return an error or make ourself the master */
842
843static int validate_master_nodeid(struct dlm_ls *ls, struct dlm_rsb *r,
844 int from_nodeid)
845{
846 if (dlm_no_directory(ls)) {
847 log_error(ls, "find_rsb keep from_nodeid %d master %d dir %d",
848 from_nodeid, r->res_master_nodeid,
849 r->res_dir_nodeid);
850 dlm_print_rsb(r);
851 return -ENOTBLK;
852 }
853
854 if (from_nodeid != r->res_dir_nodeid) {
855 /* our rsb is not master, and another node (not the dir node)
856 has sent us a request. this is much more common when our
857 master_nodeid is zero, so limit debug to non-zero. */
858
859 if (r->res_master_nodeid) {
860 log_debug(ls, "validate master from_other %d master %d "
861 "dir %d first %x %s", from_nodeid,
862 r->res_master_nodeid, r->res_dir_nodeid,
863 r->res_first_lkid, r->res_name);
864 }
865 return -ENOTBLK;
866 } else {
867 /* our rsb is not master, but the dir nodeid has sent us a
868 request; this could happen with master 0 / res_nodeid -1 */
869
870 if (r->res_master_nodeid) {
871 log_error(ls, "validate master from_dir %d master %d "
872 "first %x %s",
873 from_nodeid, r->res_master_nodeid,
874 r->res_first_lkid, r->res_name);
875 }
876
877 r->res_master_nodeid = dlm_our_nodeid();
878 r->res_nodeid = 0;
879 return 0;
880 }
881}
882
883/*
884 * We're the dir node for this res and another node wants to know the
885 * master nodeid. During normal operation (non recovery) this is only
886 * called from receive_lookup(); master lookups when the local node is
887 * the dir node are done by find_rsb().
888 *
889 * normal operation, we are the dir node for a resource
890 * . _request_lock
891 * . set_master
892 * . send_lookup
893 * . receive_lookup
894 * . dlm_master_lookup flags 0
895 *
896 * recover directory, we are rebuilding dir for all resources
897 * . dlm_recover_directory
898 * . dlm_rcom_names
899 * remote node sends back the rsb names it is master of and we are dir of
900 * . dlm_master_lookup RECOVER_DIR (fix_master 0, from_master 1)
901 * we either create new rsb setting remote node as master, or find existing
902 * rsb and set master to be the remote node.
903 *
904 * recover masters, we are finding the new master for resources
905 * . dlm_recover_masters
906 * . recover_master
907 * . dlm_send_rcom_lookup
908 * . receive_rcom_lookup
909 * . dlm_master_lookup RECOVER_MASTER (fix_master 1, from_master 0)
910 */
911
912int dlm_master_lookup(struct dlm_ls *ls, int from_nodeid, char *name, int len,
913 unsigned int flags, int *r_nodeid, int *result)
914{
915 struct dlm_rsb *r = NULL;
916 uint32_t hash, b;
917 int from_master = (flags & DLM_LU_RECOVER_DIR);
918 int fix_master = (flags & DLM_LU_RECOVER_MASTER);
919 int our_nodeid = dlm_our_nodeid();
920 int dir_nodeid, error, toss_list = 0;
921
922 if (len > DLM_RESNAME_MAXLEN)
923 return -EINVAL;
924
925 if (from_nodeid == our_nodeid) {
926 log_error(ls, "dlm_master_lookup from our_nodeid %d flags %x",
927 our_nodeid, flags);
928 return -EINVAL;
929 }
930
931 hash = jhash(name, len, 0);
932 b = hash & (ls->ls_rsbtbl_size - 1);
933
934 dir_nodeid = dlm_hash2nodeid(ls, hash);
935 if (dir_nodeid != our_nodeid) {
936 log_error(ls, "dlm_master_lookup from %d dir %d our %d h %x %d",
937 from_nodeid, dir_nodeid, our_nodeid, hash,
938 ls->ls_num_nodes);
939 *r_nodeid = -1;
940 return -EINVAL;
941 }
942
943 retry:
944 error = pre_rsb_struct(ls);
945 if (error < 0)
946 return error;
947
948 spin_lock(&ls->ls_rsbtbl[b].lock);
949 error = dlm_search_rsb_tree(&ls->ls_rsbtbl[b].keep, name, len, &r);
950 if (!error) {
951 /* because the rsb is active, we need to lock_rsb before
952 checking/changing re_master_nodeid */
953
954 hold_rsb(r);
955 spin_unlock(&ls->ls_rsbtbl[b].lock);
956 lock_rsb(r);
957 goto found;
958 }
959
960 error = dlm_search_rsb_tree(&ls->ls_rsbtbl[b].toss, name, len, &r);
961 if (error)
962 goto not_found;
963
964 /* because the rsb is inactive (on toss list), it's not refcounted
965 and lock_rsb is not used, but is protected by the rsbtbl lock */
966
967 toss_list = 1;
968 found:
969 if (r->res_dir_nodeid != our_nodeid) {
970 /* should not happen, but may as well fix it and carry on */
971 log_error(ls, "dlm_master_lookup res_dir %d our %d %s",
972 r->res_dir_nodeid, our_nodeid, r->res_name);
973 r->res_dir_nodeid = our_nodeid;
974 }
975
976 if (fix_master && dlm_is_removed(ls, r->res_master_nodeid)) {
977 /* Recovery uses this function to set a new master when
978 the previous master failed. Setting NEW_MASTER will
979 force dlm_recover_masters to call recover_master on this
980 rsb even though the res_nodeid is no longer removed. */
981
982 r->res_master_nodeid = from_nodeid;
983 r->res_nodeid = from_nodeid;
984 rsb_set_flag(r, RSB_NEW_MASTER);
985
986 if (toss_list) {
987 /* I don't think we should ever find it on toss list. */
988 log_error(ls, "dlm_master_lookup fix_master on toss");
989 dlm_dump_rsb(r);
990 }
991 }
992
993 if (from_master && (r->res_master_nodeid != from_nodeid)) {
994 /* this will happen if from_nodeid became master during
995 a previous recovery cycle, and we aborted the previous
996 cycle before recovering this master value */
997
998 log_limit(ls, "dlm_master_lookup from_master %d "
999 "master_nodeid %d res_nodeid %d first %x %s",
1000 from_nodeid, r->res_master_nodeid, r->res_nodeid,
1001 r->res_first_lkid, r->res_name);
1002
1003 if (r->res_master_nodeid == our_nodeid) {
1004 log_error(ls, "from_master %d our_master", from_nodeid);
1005 dlm_dump_rsb(r);
David Teiglandc04fecb2012-05-10 10:18:07 -05001006 goto out_found;
1007 }
1008
1009 r->res_master_nodeid = from_nodeid;
1010 r->res_nodeid = from_nodeid;
1011 rsb_set_flag(r, RSB_NEW_MASTER);
1012 }
1013
1014 if (!r->res_master_nodeid) {
1015 /* this will happen if recovery happens while we're looking
1016 up the master for this rsb */
1017
1018 log_debug(ls, "dlm_master_lookup master 0 to %d first %x %s",
1019 from_nodeid, r->res_first_lkid, r->res_name);
1020 r->res_master_nodeid = from_nodeid;
1021 r->res_nodeid = from_nodeid;
1022 }
1023
1024 if (!from_master && !fix_master &&
1025 (r->res_master_nodeid == from_nodeid)) {
1026 /* this can happen when the master sends remove, the dir node
1027 finds the rsb on the keep list and ignores the remove,
1028 and the former master sends a lookup */
1029
1030 log_limit(ls, "dlm_master_lookup from master %d flags %x "
1031 "first %x %s", from_nodeid, flags,
1032 r->res_first_lkid, r->res_name);
1033 }
1034
1035 out_found:
1036 *r_nodeid = r->res_master_nodeid;
1037 if (result)
1038 *result = DLM_LU_MATCH;
1039
1040 if (toss_list) {
1041 r->res_toss_time = jiffies;
1042 /* the rsb was inactive (on toss list) */
1043 spin_unlock(&ls->ls_rsbtbl[b].lock);
1044 } else {
1045 /* the rsb was active */
1046 unlock_rsb(r);
1047 put_rsb(r);
1048 }
1049 return 0;
1050
1051 not_found:
1052 error = get_rsb_struct(ls, name, len, &r);
1053 if (error == -EAGAIN) {
1054 spin_unlock(&ls->ls_rsbtbl[b].lock);
1055 goto retry;
1056 }
1057 if (error)
1058 goto out_unlock;
1059
1060 r->res_hash = hash;
1061 r->res_bucket = b;
1062 r->res_dir_nodeid = our_nodeid;
1063 r->res_master_nodeid = from_nodeid;
1064 r->res_nodeid = from_nodeid;
1065 kref_init(&r->res_ref);
1066 r->res_toss_time = jiffies;
1067
1068 error = rsb_insert(r, &ls->ls_rsbtbl[b].toss);
1069 if (error) {
1070 /* should never happen */
1071 dlm_free_rsb(r);
1072 spin_unlock(&ls->ls_rsbtbl[b].lock);
1073 goto retry;
1074 }
1075
1076 if (result)
1077 *result = DLM_LU_ADD;
1078 *r_nodeid = from_nodeid;
1079 error = 0;
1080 out_unlock:
1081 spin_unlock(&ls->ls_rsbtbl[b].lock);
1082 return error;
1083}
1084
David Teigland6d40c4a2012-04-23 16:36:01 -05001085static void dlm_dump_rsb_hash(struct dlm_ls *ls, uint32_t hash)
1086{
1087 struct rb_node *n;
1088 struct dlm_rsb *r;
1089 int i;
1090
1091 for (i = 0; i < ls->ls_rsbtbl_size; i++) {
1092 spin_lock(&ls->ls_rsbtbl[i].lock);
1093 for (n = rb_first(&ls->ls_rsbtbl[i].keep); n; n = rb_next(n)) {
1094 r = rb_entry(n, struct dlm_rsb, res_hashnode);
1095 if (r->res_hash == hash)
1096 dlm_dump_rsb(r);
1097 }
1098 spin_unlock(&ls->ls_rsbtbl[i].lock);
1099 }
1100}
1101
David Teiglandc04fecb2012-05-10 10:18:07 -05001102void dlm_dump_rsb_name(struct dlm_ls *ls, char *name, int len)
David Teiglande7fd4172006-01-18 09:30:29 +00001103{
David Teiglandc04fecb2012-05-10 10:18:07 -05001104 struct dlm_rsb *r = NULL;
1105 uint32_t hash, b;
1106 int error;
David Teiglande7fd4172006-01-18 09:30:29 +00001107
David Teiglandc04fecb2012-05-10 10:18:07 -05001108 hash = jhash(name, len, 0);
1109 b = hash & (ls->ls_rsbtbl_size - 1);
1110
1111 spin_lock(&ls->ls_rsbtbl[b].lock);
1112 error = dlm_search_rsb_tree(&ls->ls_rsbtbl[b].keep, name, len, &r);
1113 if (!error)
1114 goto out_dump;
1115
1116 error = dlm_search_rsb_tree(&ls->ls_rsbtbl[b].toss, name, len, &r);
1117 if (error)
1118 goto out;
1119 out_dump:
1120 dlm_dump_rsb(r);
1121 out:
1122 spin_unlock(&ls->ls_rsbtbl[b].lock);
David Teiglande7fd4172006-01-18 09:30:29 +00001123}
1124
1125static void toss_rsb(struct kref *kref)
1126{
1127 struct dlm_rsb *r = container_of(kref, struct dlm_rsb, res_ref);
1128 struct dlm_ls *ls = r->res_ls;
1129
1130 DLM_ASSERT(list_empty(&r->res_root_list), dlm_print_rsb(r););
1131 kref_init(&r->res_ref);
Bob Peterson9beb3bf2011-10-26 15:24:55 -05001132 rb_erase(&r->res_hashnode, &ls->ls_rsbtbl[r->res_bucket].keep);
1133 rsb_insert(r, &ls->ls_rsbtbl[r->res_bucket].toss);
David Teiglande7fd4172006-01-18 09:30:29 +00001134 r->res_toss_time = jiffies;
David Teiglandf1172282013-01-07 11:03:42 -06001135 ls->ls_rsbtbl[r->res_bucket].flags |= DLM_RTF_SHRINK;
David Teiglande7fd4172006-01-18 09:30:29 +00001136 if (r->res_lvbptr) {
David Teigland52bda2b2007-11-07 09:06:49 -06001137 dlm_free_lvb(r->res_lvbptr);
David Teiglande7fd4172006-01-18 09:30:29 +00001138 r->res_lvbptr = NULL;
1139 }
1140}
1141
David Teiglande7fd4172006-01-18 09:30:29 +00001142/* See comment for unhold_lkb */
1143
1144static void unhold_rsb(struct dlm_rsb *r)
1145{
1146 int rv;
1147 rv = kref_put(&r->res_ref, toss_rsb);
David Teiglanda345da32006-08-18 11:54:25 -05001148 DLM_ASSERT(!rv, dlm_dump_rsb(r););
David Teiglande7fd4172006-01-18 09:30:29 +00001149}
1150
1151static void kill_rsb(struct kref *kref)
1152{
1153 struct dlm_rsb *r = container_of(kref, struct dlm_rsb, res_ref);
1154
1155 /* All work is done after the return from kref_put() so we
1156 can release the write_lock before the remove and free. */
1157
David Teiglanda345da32006-08-18 11:54:25 -05001158 DLM_ASSERT(list_empty(&r->res_lookup), dlm_dump_rsb(r););
1159 DLM_ASSERT(list_empty(&r->res_grantqueue), dlm_dump_rsb(r););
1160 DLM_ASSERT(list_empty(&r->res_convertqueue), dlm_dump_rsb(r););
1161 DLM_ASSERT(list_empty(&r->res_waitqueue), dlm_dump_rsb(r););
1162 DLM_ASSERT(list_empty(&r->res_root_list), dlm_dump_rsb(r););
1163 DLM_ASSERT(list_empty(&r->res_recover_list), dlm_dump_rsb(r););
David Teiglande7fd4172006-01-18 09:30:29 +00001164}
1165
1166/* Attaching/detaching lkb's from rsb's is for rsb reference counting.
1167 The rsb must exist as long as any lkb's for it do. */
1168
1169static void attach_lkb(struct dlm_rsb *r, struct dlm_lkb *lkb)
1170{
1171 hold_rsb(r);
1172 lkb->lkb_resource = r;
1173}
1174
1175static void detach_lkb(struct dlm_lkb *lkb)
1176{
1177 if (lkb->lkb_resource) {
1178 put_rsb(lkb->lkb_resource);
1179 lkb->lkb_resource = NULL;
1180 }
1181}
1182
1183static int create_lkb(struct dlm_ls *ls, struct dlm_lkb **lkb_ret)
1184{
David Teigland3d6aa672011-07-06 17:00:54 -05001185 struct dlm_lkb *lkb;
Tejun Heo2a86b3e2013-02-27 17:04:49 -08001186 int rv;
David Teiglande7fd4172006-01-18 09:30:29 +00001187
David Teigland52bda2b2007-11-07 09:06:49 -06001188 lkb = dlm_allocate_lkb(ls);
David Teiglande7fd4172006-01-18 09:30:29 +00001189 if (!lkb)
1190 return -ENOMEM;
1191
1192 lkb->lkb_nodeid = -1;
1193 lkb->lkb_grmode = DLM_LOCK_IV;
1194 kref_init(&lkb->lkb_ref);
David Teigland34e22be2006-07-18 11:24:04 -05001195 INIT_LIST_HEAD(&lkb->lkb_ownqueue);
David Teiglandef0c2bb2007-03-28 09:56:46 -05001196 INIT_LIST_HEAD(&lkb->lkb_rsb_lookup);
David Teigland3ae1acf2007-05-18 08:59:31 -05001197 INIT_LIST_HEAD(&lkb->lkb_time_list);
David Teigland23e8e1a2011-04-05 13:16:24 -05001198 INIT_LIST_HEAD(&lkb->lkb_cb_list);
1199 mutex_init(&lkb->lkb_cb_mutex);
1200 INIT_WORK(&lkb->lkb_cb_work, dlm_callback_work);
David Teiglande7fd4172006-01-18 09:30:29 +00001201
Tejun Heo2a86b3e2013-02-27 17:04:49 -08001202 idr_preload(GFP_NOFS);
David Teigland3d6aa672011-07-06 17:00:54 -05001203 spin_lock(&ls->ls_lkbidr_spin);
Tejun Heo2a86b3e2013-02-27 17:04:49 -08001204 rv = idr_alloc(&ls->ls_lkbidr, lkb, 1, 0, GFP_NOWAIT);
1205 if (rv >= 0)
1206 lkb->lkb_id = rv;
David Teigland3d6aa672011-07-06 17:00:54 -05001207 spin_unlock(&ls->ls_lkbidr_spin);
Tejun Heo2a86b3e2013-02-27 17:04:49 -08001208 idr_preload_end();
David Teiglande7fd4172006-01-18 09:30:29 +00001209
David Teigland3d6aa672011-07-06 17:00:54 -05001210 if (rv < 0) {
1211 log_error(ls, "create_lkb idr error %d", rv);
Vasily Averin23851e92018-11-15 13:18:18 +03001212 dlm_free_lkb(lkb);
David Teigland3d6aa672011-07-06 17:00:54 -05001213 return rv;
David Teiglande7fd4172006-01-18 09:30:29 +00001214 }
1215
David Teiglande7fd4172006-01-18 09:30:29 +00001216 *lkb_ret = lkb;
1217 return 0;
1218}
1219
David Teiglande7fd4172006-01-18 09:30:29 +00001220static int find_lkb(struct dlm_ls *ls, uint32_t lkid, struct dlm_lkb **lkb_ret)
1221{
1222 struct dlm_lkb *lkb;
David Teiglande7fd4172006-01-18 09:30:29 +00001223
David Teigland3d6aa672011-07-06 17:00:54 -05001224 spin_lock(&ls->ls_lkbidr_spin);
1225 lkb = idr_find(&ls->ls_lkbidr, lkid);
David Teiglande7fd4172006-01-18 09:30:29 +00001226 if (lkb)
1227 kref_get(&lkb->lkb_ref);
David Teigland3d6aa672011-07-06 17:00:54 -05001228 spin_unlock(&ls->ls_lkbidr_spin);
David Teiglande7fd4172006-01-18 09:30:29 +00001229
1230 *lkb_ret = lkb;
1231 return lkb ? 0 : -ENOENT;
1232}
1233
1234static void kill_lkb(struct kref *kref)
1235{
1236 struct dlm_lkb *lkb = container_of(kref, struct dlm_lkb, lkb_ref);
1237
1238 /* All work is done after the return from kref_put() so we
1239 can release the write_lock before the detach_lkb */
1240
1241 DLM_ASSERT(!lkb->lkb_status, dlm_print_lkb(lkb););
1242}
1243
David Teiglandb3f58d82006-02-28 11:16:37 -05001244/* __put_lkb() is used when an lkb may not have an rsb attached to
1245 it so we need to provide the lockspace explicitly */
1246
1247static int __put_lkb(struct dlm_ls *ls, struct dlm_lkb *lkb)
David Teiglande7fd4172006-01-18 09:30:29 +00001248{
David Teigland3d6aa672011-07-06 17:00:54 -05001249 uint32_t lkid = lkb->lkb_id;
David Teiglande7fd4172006-01-18 09:30:29 +00001250
David Teigland3d6aa672011-07-06 17:00:54 -05001251 spin_lock(&ls->ls_lkbidr_spin);
David Teiglande7fd4172006-01-18 09:30:29 +00001252 if (kref_put(&lkb->lkb_ref, kill_lkb)) {
David Teigland3d6aa672011-07-06 17:00:54 -05001253 idr_remove(&ls->ls_lkbidr, lkid);
1254 spin_unlock(&ls->ls_lkbidr_spin);
David Teiglande7fd4172006-01-18 09:30:29 +00001255
1256 detach_lkb(lkb);
1257
1258 /* for local/process lkbs, lvbptr points to caller's lksb */
1259 if (lkb->lkb_lvbptr && is_master_copy(lkb))
David Teigland52bda2b2007-11-07 09:06:49 -06001260 dlm_free_lvb(lkb->lkb_lvbptr);
1261 dlm_free_lkb(lkb);
David Teiglande7fd4172006-01-18 09:30:29 +00001262 return 1;
1263 } else {
David Teigland3d6aa672011-07-06 17:00:54 -05001264 spin_unlock(&ls->ls_lkbidr_spin);
David Teiglande7fd4172006-01-18 09:30:29 +00001265 return 0;
1266 }
1267}
1268
1269int dlm_put_lkb(struct dlm_lkb *lkb)
1270{
David Teiglandb3f58d82006-02-28 11:16:37 -05001271 struct dlm_ls *ls;
1272
1273 DLM_ASSERT(lkb->lkb_resource, dlm_print_lkb(lkb););
1274 DLM_ASSERT(lkb->lkb_resource->res_ls, dlm_print_lkb(lkb););
1275
1276 ls = lkb->lkb_resource->res_ls;
1277 return __put_lkb(ls, lkb);
David Teiglande7fd4172006-01-18 09:30:29 +00001278}
1279
1280/* This is only called to add a reference when the code already holds
1281 a valid reference to the lkb, so there's no need for locking. */
1282
1283static inline void hold_lkb(struct dlm_lkb *lkb)
1284{
1285 kref_get(&lkb->lkb_ref);
1286}
1287
1288/* This is called when we need to remove a reference and are certain
1289 it's not the last ref. e.g. del_lkb is always called between a
1290 find_lkb/put_lkb and is always the inverse of a previous add_lkb.
1291 put_lkb would work fine, but would involve unnecessary locking */
1292
1293static inline void unhold_lkb(struct dlm_lkb *lkb)
1294{
1295 int rv;
1296 rv = kref_put(&lkb->lkb_ref, kill_lkb);
1297 DLM_ASSERT(!rv, dlm_print_lkb(lkb););
1298}
1299
1300static void lkb_add_ordered(struct list_head *new, struct list_head *head,
1301 int mode)
1302{
1303 struct dlm_lkb *lkb = NULL;
1304
1305 list_for_each_entry(lkb, head, lkb_statequeue)
1306 if (lkb->lkb_rqmode < mode)
1307 break;
1308
Dan Carpenter99fb19d2010-03-22 15:03:54 +03001309 __list_add(new, lkb->lkb_statequeue.prev, &lkb->lkb_statequeue);
David Teiglande7fd4172006-01-18 09:30:29 +00001310}
1311
1312/* add/remove lkb to rsb's grant/convert/wait queue */
1313
1314static void add_lkb(struct dlm_rsb *r, struct dlm_lkb *lkb, int status)
1315{
1316 kref_get(&lkb->lkb_ref);
1317
1318 DLM_ASSERT(!lkb->lkb_status, dlm_print_lkb(lkb););
1319
David Teiglandeeda4182008-12-09 14:12:21 -06001320 lkb->lkb_timestamp = ktime_get();
1321
David Teiglande7fd4172006-01-18 09:30:29 +00001322 lkb->lkb_status = status;
1323
1324 switch (status) {
1325 case DLM_LKSTS_WAITING:
1326 if (lkb->lkb_exflags & DLM_LKF_HEADQUE)
1327 list_add(&lkb->lkb_statequeue, &r->res_waitqueue);
1328 else
1329 list_add_tail(&lkb->lkb_statequeue, &r->res_waitqueue);
1330 break;
1331 case DLM_LKSTS_GRANTED:
1332 /* convention says granted locks kept in order of grmode */
1333 lkb_add_ordered(&lkb->lkb_statequeue, &r->res_grantqueue,
1334 lkb->lkb_grmode);
1335 break;
1336 case DLM_LKSTS_CONVERT:
1337 if (lkb->lkb_exflags & DLM_LKF_HEADQUE)
1338 list_add(&lkb->lkb_statequeue, &r->res_convertqueue);
1339 else
1340 list_add_tail(&lkb->lkb_statequeue,
1341 &r->res_convertqueue);
1342 break;
1343 default:
1344 DLM_ASSERT(0, dlm_print_lkb(lkb); printk("sts=%d\n", status););
1345 }
1346}
1347
1348static void del_lkb(struct dlm_rsb *r, struct dlm_lkb *lkb)
1349{
1350 lkb->lkb_status = 0;
1351 list_del(&lkb->lkb_statequeue);
1352 unhold_lkb(lkb);
1353}
1354
1355static void move_lkb(struct dlm_rsb *r, struct dlm_lkb *lkb, int sts)
1356{
1357 hold_lkb(lkb);
1358 del_lkb(r, lkb);
1359 add_lkb(r, lkb, sts);
1360 unhold_lkb(lkb);
1361}
1362
David Teiglandef0c2bb2007-03-28 09:56:46 -05001363static int msg_reply_type(int mstype)
1364{
1365 switch (mstype) {
1366 case DLM_MSG_REQUEST:
1367 return DLM_MSG_REQUEST_REPLY;
1368 case DLM_MSG_CONVERT:
1369 return DLM_MSG_CONVERT_REPLY;
1370 case DLM_MSG_UNLOCK:
1371 return DLM_MSG_UNLOCK_REPLY;
1372 case DLM_MSG_CANCEL:
1373 return DLM_MSG_CANCEL_REPLY;
1374 case DLM_MSG_LOOKUP:
1375 return DLM_MSG_LOOKUP_REPLY;
1376 }
1377 return -1;
1378}
1379
David Teiglandc6ff6692011-03-28 14:17:26 -05001380static int nodeid_warned(int nodeid, int num_nodes, int *warned)
1381{
1382 int i;
1383
1384 for (i = 0; i < num_nodes; i++) {
1385 if (!warned[i]) {
1386 warned[i] = nodeid;
1387 return 0;
1388 }
1389 if (warned[i] == nodeid)
1390 return 1;
1391 }
1392 return 0;
1393}
1394
1395void dlm_scan_waiters(struct dlm_ls *ls)
1396{
1397 struct dlm_lkb *lkb;
David Teiglandc6ff6692011-03-28 14:17:26 -05001398 s64 us;
1399 s64 debug_maxus = 0;
1400 u32 debug_scanned = 0;
1401 u32 debug_expired = 0;
1402 int num_nodes = 0;
1403 int *warned = NULL;
1404
1405 if (!dlm_config.ci_waitwarn_us)
1406 return;
1407
1408 mutex_lock(&ls->ls_waiters_mutex);
1409
1410 list_for_each_entry(lkb, &ls->ls_waiters, lkb_wait_reply) {
Thomas Gleixner1f3a8e42016-12-25 12:43:07 +01001411 if (!lkb->lkb_wait_time)
David Teiglandc6ff6692011-03-28 14:17:26 -05001412 continue;
1413
1414 debug_scanned++;
1415
1416 us = ktime_to_us(ktime_sub(ktime_get(), lkb->lkb_wait_time));
1417
1418 if (us < dlm_config.ci_waitwarn_us)
1419 continue;
1420
Thomas Gleixner1f3a8e42016-12-25 12:43:07 +01001421 lkb->lkb_wait_time = 0;
David Teiglandc6ff6692011-03-28 14:17:26 -05001422
1423 debug_expired++;
1424 if (us > debug_maxus)
1425 debug_maxus = us;
1426
1427 if (!num_nodes) {
1428 num_nodes = ls->ls_num_nodes;
Markus Elfringfbb10082017-05-06 08:38:49 +02001429 warned = kcalloc(num_nodes, sizeof(int), GFP_KERNEL);
David Teiglandc6ff6692011-03-28 14:17:26 -05001430 }
1431 if (!warned)
1432 continue;
1433 if (nodeid_warned(lkb->lkb_wait_nodeid, num_nodes, warned))
1434 continue;
1435
1436 log_error(ls, "waitwarn %x %lld %d us check connection to "
1437 "node %d", lkb->lkb_id, (long long)us,
1438 dlm_config.ci_waitwarn_us, lkb->lkb_wait_nodeid);
1439 }
1440 mutex_unlock(&ls->ls_waiters_mutex);
Jesper Juhl5d708282011-07-10 22:54:31 +02001441 kfree(warned);
David Teiglandc6ff6692011-03-28 14:17:26 -05001442
1443 if (debug_expired)
1444 log_debug(ls, "scan_waiters %u warn %u over %d us max %lld us",
1445 debug_scanned, debug_expired,
1446 dlm_config.ci_waitwarn_us, (long long)debug_maxus);
1447}
1448
David Teiglande7fd4172006-01-18 09:30:29 +00001449/* add/remove lkb from global waiters list of lkb's waiting for
1450 a reply from a remote node */
1451
David Teiglandc6ff6692011-03-28 14:17:26 -05001452static int add_to_waiters(struct dlm_lkb *lkb, int mstype, int to_nodeid)
David Teiglande7fd4172006-01-18 09:30:29 +00001453{
1454 struct dlm_ls *ls = lkb->lkb_resource->res_ls;
David Teiglandef0c2bb2007-03-28 09:56:46 -05001455 int error = 0;
David Teiglande7fd4172006-01-18 09:30:29 +00001456
David Teigland90135922006-01-20 08:47:07 +00001457 mutex_lock(&ls->ls_waiters_mutex);
David Teiglandef0c2bb2007-03-28 09:56:46 -05001458
1459 if (is_overlap_unlock(lkb) ||
1460 (is_overlap_cancel(lkb) && (mstype == DLM_MSG_CANCEL))) {
1461 error = -EINVAL;
David Teiglande7fd4172006-01-18 09:30:29 +00001462 goto out;
1463 }
David Teiglandef0c2bb2007-03-28 09:56:46 -05001464
1465 if (lkb->lkb_wait_type || is_overlap_cancel(lkb)) {
1466 switch (mstype) {
1467 case DLM_MSG_UNLOCK:
1468 lkb->lkb_flags |= DLM_IFL_OVERLAP_UNLOCK;
1469 break;
1470 case DLM_MSG_CANCEL:
1471 lkb->lkb_flags |= DLM_IFL_OVERLAP_CANCEL;
1472 break;
1473 default:
1474 error = -EBUSY;
1475 goto out;
1476 }
1477 lkb->lkb_wait_count++;
1478 hold_lkb(lkb);
1479
David Teigland43279e52009-01-28 14:37:54 -06001480 log_debug(ls, "addwait %x cur %d overlap %d count %d f %x",
David Teiglandef0c2bb2007-03-28 09:56:46 -05001481 lkb->lkb_id, lkb->lkb_wait_type, mstype,
1482 lkb->lkb_wait_count, lkb->lkb_flags);
1483 goto out;
1484 }
1485
1486 DLM_ASSERT(!lkb->lkb_wait_count,
1487 dlm_print_lkb(lkb);
1488 printk("wait_count %d\n", lkb->lkb_wait_count););
1489
1490 lkb->lkb_wait_count++;
David Teiglande7fd4172006-01-18 09:30:29 +00001491 lkb->lkb_wait_type = mstype;
David Teiglandc6ff6692011-03-28 14:17:26 -05001492 lkb->lkb_wait_time = ktime_get();
1493 lkb->lkb_wait_nodeid = to_nodeid; /* for debugging */
David Teiglandef0c2bb2007-03-28 09:56:46 -05001494 hold_lkb(lkb);
David Teiglande7fd4172006-01-18 09:30:29 +00001495 list_add(&lkb->lkb_wait_reply, &ls->ls_waiters);
1496 out:
David Teiglandef0c2bb2007-03-28 09:56:46 -05001497 if (error)
David Teigland43279e52009-01-28 14:37:54 -06001498 log_error(ls, "addwait error %x %d flags %x %d %d %s",
David Teiglandef0c2bb2007-03-28 09:56:46 -05001499 lkb->lkb_id, error, lkb->lkb_flags, mstype,
1500 lkb->lkb_wait_type, lkb->lkb_resource->res_name);
David Teigland90135922006-01-20 08:47:07 +00001501 mutex_unlock(&ls->ls_waiters_mutex);
David Teiglandef0c2bb2007-03-28 09:56:46 -05001502 return error;
David Teiglande7fd4172006-01-18 09:30:29 +00001503}
1504
David Teiglandb790c3b2007-01-24 10:21:33 -06001505/* We clear the RESEND flag because we might be taking an lkb off the waiters
1506 list as part of process_requestqueue (e.g. a lookup that has an optimized
1507 request reply on the requestqueue) between dlm_recover_waiters_pre() which
1508 set RESEND and dlm_recover_waiters_post() */
1509
David Teigland43279e52009-01-28 14:37:54 -06001510static int _remove_from_waiters(struct dlm_lkb *lkb, int mstype,
1511 struct dlm_message *ms)
David Teiglande7fd4172006-01-18 09:30:29 +00001512{
David Teiglandef0c2bb2007-03-28 09:56:46 -05001513 struct dlm_ls *ls = lkb->lkb_resource->res_ls;
1514 int overlap_done = 0;
David Teiglande7fd4172006-01-18 09:30:29 +00001515
David Teiglandef0c2bb2007-03-28 09:56:46 -05001516 if (is_overlap_unlock(lkb) && (mstype == DLM_MSG_UNLOCK_REPLY)) {
David Teigland43279e52009-01-28 14:37:54 -06001517 log_debug(ls, "remwait %x unlock_reply overlap", lkb->lkb_id);
David Teiglandef0c2bb2007-03-28 09:56:46 -05001518 lkb->lkb_flags &= ~DLM_IFL_OVERLAP_UNLOCK;
1519 overlap_done = 1;
1520 goto out_del;
David Teiglande7fd4172006-01-18 09:30:29 +00001521 }
David Teiglandef0c2bb2007-03-28 09:56:46 -05001522
1523 if (is_overlap_cancel(lkb) && (mstype == DLM_MSG_CANCEL_REPLY)) {
David Teigland43279e52009-01-28 14:37:54 -06001524 log_debug(ls, "remwait %x cancel_reply overlap", lkb->lkb_id);
David Teiglandef0c2bb2007-03-28 09:56:46 -05001525 lkb->lkb_flags &= ~DLM_IFL_OVERLAP_CANCEL;
1526 overlap_done = 1;
1527 goto out_del;
1528 }
1529
David Teigland43279e52009-01-28 14:37:54 -06001530 /* Cancel state was preemptively cleared by a successful convert,
1531 see next comment, nothing to do. */
1532
1533 if ((mstype == DLM_MSG_CANCEL_REPLY) &&
1534 (lkb->lkb_wait_type != DLM_MSG_CANCEL)) {
1535 log_debug(ls, "remwait %x cancel_reply wait_type %d",
1536 lkb->lkb_id, lkb->lkb_wait_type);
1537 return -1;
1538 }
1539
1540 /* Remove for the convert reply, and premptively remove for the
1541 cancel reply. A convert has been granted while there's still
1542 an outstanding cancel on it (the cancel is moot and the result
1543 in the cancel reply should be 0). We preempt the cancel reply
1544 because the app gets the convert result and then can follow up
1545 with another op, like convert. This subsequent op would see the
1546 lingering state of the cancel and fail with -EBUSY. */
1547
1548 if ((mstype == DLM_MSG_CONVERT_REPLY) &&
1549 (lkb->lkb_wait_type == DLM_MSG_CONVERT) &&
1550 is_overlap_cancel(lkb) && ms && !ms->m_result) {
1551 log_debug(ls, "remwait %x convert_reply zap overlap_cancel",
1552 lkb->lkb_id);
1553 lkb->lkb_wait_type = 0;
1554 lkb->lkb_flags &= ~DLM_IFL_OVERLAP_CANCEL;
1555 lkb->lkb_wait_count--;
1556 goto out_del;
1557 }
1558
David Teiglandef0c2bb2007-03-28 09:56:46 -05001559 /* N.B. type of reply may not always correspond to type of original
1560 msg due to lookup->request optimization, verify others? */
1561
1562 if (lkb->lkb_wait_type) {
1563 lkb->lkb_wait_type = 0;
1564 goto out_del;
1565 }
1566
David Teigland6d40c4a2012-04-23 16:36:01 -05001567 log_error(ls, "remwait error %x remote %d %x msg %d flags %x no wait",
1568 lkb->lkb_id, ms ? ms->m_header.h_nodeid : 0, lkb->lkb_remid,
1569 mstype, lkb->lkb_flags);
David Teiglandef0c2bb2007-03-28 09:56:46 -05001570 return -1;
1571
1572 out_del:
1573 /* the force-unlock/cancel has completed and we haven't recvd a reply
1574 to the op that was in progress prior to the unlock/cancel; we
1575 give up on any reply to the earlier op. FIXME: not sure when/how
1576 this would happen */
1577
1578 if (overlap_done && lkb->lkb_wait_type) {
David Teigland43279e52009-01-28 14:37:54 -06001579 log_error(ls, "remwait error %x reply %d wait_type %d overlap",
David Teiglandef0c2bb2007-03-28 09:56:46 -05001580 lkb->lkb_id, mstype, lkb->lkb_wait_type);
1581 lkb->lkb_wait_count--;
1582 lkb->lkb_wait_type = 0;
1583 }
1584
1585 DLM_ASSERT(lkb->lkb_wait_count, dlm_print_lkb(lkb););
1586
David Teiglandb790c3b2007-01-24 10:21:33 -06001587 lkb->lkb_flags &= ~DLM_IFL_RESEND;
David Teiglandef0c2bb2007-03-28 09:56:46 -05001588 lkb->lkb_wait_count--;
1589 if (!lkb->lkb_wait_count)
1590 list_del_init(&lkb->lkb_wait_reply);
David Teiglande7fd4172006-01-18 09:30:29 +00001591 unhold_lkb(lkb);
David Teiglandef0c2bb2007-03-28 09:56:46 -05001592 return 0;
David Teiglande7fd4172006-01-18 09:30:29 +00001593}
1594
David Teiglandef0c2bb2007-03-28 09:56:46 -05001595static int remove_from_waiters(struct dlm_lkb *lkb, int mstype)
David Teiglande7fd4172006-01-18 09:30:29 +00001596{
1597 struct dlm_ls *ls = lkb->lkb_resource->res_ls;
1598 int error;
1599
David Teigland90135922006-01-20 08:47:07 +00001600 mutex_lock(&ls->ls_waiters_mutex);
David Teigland43279e52009-01-28 14:37:54 -06001601 error = _remove_from_waiters(lkb, mstype, NULL);
David Teigland90135922006-01-20 08:47:07 +00001602 mutex_unlock(&ls->ls_waiters_mutex);
David Teiglande7fd4172006-01-18 09:30:29 +00001603 return error;
1604}
1605
David Teiglandef0c2bb2007-03-28 09:56:46 -05001606/* Handles situations where we might be processing a "fake" or "stub" reply in
1607 which we can't try to take waiters_mutex again. */
1608
1609static int remove_from_waiters_ms(struct dlm_lkb *lkb, struct dlm_message *ms)
1610{
1611 struct dlm_ls *ls = lkb->lkb_resource->res_ls;
1612 int error;
1613
David Teigland2a7ce0e2011-04-04 15:19:59 -05001614 if (ms->m_flags != DLM_IFL_STUB_MS)
David Teiglandef0c2bb2007-03-28 09:56:46 -05001615 mutex_lock(&ls->ls_waiters_mutex);
David Teigland43279e52009-01-28 14:37:54 -06001616 error = _remove_from_waiters(lkb, ms->m_type, ms);
David Teigland2a7ce0e2011-04-04 15:19:59 -05001617 if (ms->m_flags != DLM_IFL_STUB_MS)
David Teiglandef0c2bb2007-03-28 09:56:46 -05001618 mutex_unlock(&ls->ls_waiters_mutex);
1619 return error;
1620}
1621
David Teigland05c32f42012-06-14 12:17:32 -05001622/* If there's an rsb for the same resource being removed, ensure
1623 that the remove message is sent before the new lookup message.
1624 It should be rare to need a delay here, but if not, then it may
1625 be worthwhile to add a proper wait mechanism rather than a delay. */
David Teiglande7fd4172006-01-18 09:30:29 +00001626
David Teigland05c32f42012-06-14 12:17:32 -05001627static void wait_pending_remove(struct dlm_rsb *r)
David Teiglande7fd4172006-01-18 09:30:29 +00001628{
David Teigland05c32f42012-06-14 12:17:32 -05001629 struct dlm_ls *ls = r->res_ls;
1630 restart:
1631 spin_lock(&ls->ls_remove_spin);
1632 if (ls->ls_remove_len &&
1633 !rsb_cmp(r, ls->ls_remove_name, ls->ls_remove_len)) {
1634 log_debug(ls, "delay lookup for remove dir %d %s",
1635 r->res_dir_nodeid, r->res_name);
1636 spin_unlock(&ls->ls_remove_spin);
1637 msleep(1);
1638 goto restart;
1639 }
1640 spin_unlock(&ls->ls_remove_spin);
1641}
1642
1643/*
1644 * ls_remove_spin protects ls_remove_name and ls_remove_len which are
1645 * read by other threads in wait_pending_remove. ls_remove_names
1646 * and ls_remove_lens are only used by the scan thread, so they do
1647 * not need protection.
1648 */
1649
1650static void shrink_bucket(struct dlm_ls *ls, int b)
1651{
1652 struct rb_node *n, *next;
David Teiglande7fd4172006-01-18 09:30:29 +00001653 struct dlm_rsb *r;
David Teigland05c32f42012-06-14 12:17:32 -05001654 char *name;
David Teiglandc04fecb2012-05-10 10:18:07 -05001655 int our_nodeid = dlm_our_nodeid();
David Teigland05c32f42012-06-14 12:17:32 -05001656 int remote_count = 0;
David Teiglandf1172282013-01-07 11:03:42 -06001657 int need_shrink = 0;
David Teigland05c32f42012-06-14 12:17:32 -05001658 int i, len, rv;
David Teiglande7fd4172006-01-18 09:30:29 +00001659
David Teigland05c32f42012-06-14 12:17:32 -05001660 memset(&ls->ls_remove_lens, 0, sizeof(int) * DLM_REMOVE_NAMES_MAX);
David Teiglandc04fecb2012-05-10 10:18:07 -05001661
David Teigland05c32f42012-06-14 12:17:32 -05001662 spin_lock(&ls->ls_rsbtbl[b].lock);
David Teiglandf1172282013-01-07 11:03:42 -06001663
1664 if (!(ls->ls_rsbtbl[b].flags & DLM_RTF_SHRINK)) {
1665 spin_unlock(&ls->ls_rsbtbl[b].lock);
1666 return;
1667 }
1668
David Teigland05c32f42012-06-14 12:17:32 -05001669 for (n = rb_first(&ls->ls_rsbtbl[b].toss); n; n = next) {
1670 next = rb_next(n);
1671 r = rb_entry(n, struct dlm_rsb, res_hashnode);
David Teiglandc04fecb2012-05-10 10:18:07 -05001672
David Teigland05c32f42012-06-14 12:17:32 -05001673 /* If we're the directory record for this rsb, and
1674 we're not the master of it, then we need to wait
1675 for the master node to send us a dir remove for
1676 before removing the dir record. */
David Teiglandc04fecb2012-05-10 10:18:07 -05001677
David Teigland05c32f42012-06-14 12:17:32 -05001678 if (!dlm_no_directory(ls) &&
1679 (r->res_master_nodeid != our_nodeid) &&
1680 (dlm_dir_nodeid(r) == our_nodeid)) {
1681 continue;
David Teiglande7fd4172006-01-18 09:30:29 +00001682 }
1683
David Teiglandf1172282013-01-07 11:03:42 -06001684 need_shrink = 1;
1685
David Teigland05c32f42012-06-14 12:17:32 -05001686 if (!time_after_eq(jiffies, r->res_toss_time +
1687 dlm_config.ci_toss_secs * HZ)) {
1688 continue;
David Teiglande7fd4172006-01-18 09:30:29 +00001689 }
1690
David Teigland05c32f42012-06-14 12:17:32 -05001691 if (!dlm_no_directory(ls) &&
1692 (r->res_master_nodeid == our_nodeid) &&
1693 (dlm_dir_nodeid(r) != our_nodeid)) {
David Teiglande7fd4172006-01-18 09:30:29 +00001694
David Teiglandc04fecb2012-05-10 10:18:07 -05001695 /* We're the master of this rsb but we're not
1696 the directory record, so we need to tell the
1697 dir node to remove the dir record. */
1698
David Teigland05c32f42012-06-14 12:17:32 -05001699 ls->ls_remove_lens[remote_count] = r->res_length;
1700 memcpy(ls->ls_remove_names[remote_count], r->res_name,
1701 DLM_RESNAME_MAXLEN);
1702 remote_count++;
David Teiglandc04fecb2012-05-10 10:18:07 -05001703
David Teigland05c32f42012-06-14 12:17:32 -05001704 if (remote_count >= DLM_REMOVE_NAMES_MAX)
1705 break;
1706 continue;
David Teiglande7fd4172006-01-18 09:30:29 +00001707 }
David Teiglande7fd4172006-01-18 09:30:29 +00001708
David Teigland05c32f42012-06-14 12:17:32 -05001709 if (!kref_put(&r->res_ref, kill_rsb)) {
1710 log_error(ls, "tossed rsb in use %s", r->res_name);
1711 continue;
1712 }
1713
1714 rb_erase(&r->res_hashnode, &ls->ls_rsbtbl[b].toss);
1715 dlm_free_rsb(r);
1716 }
David Teiglandf1172282013-01-07 11:03:42 -06001717
1718 if (need_shrink)
1719 ls->ls_rsbtbl[b].flags |= DLM_RTF_SHRINK;
1720 else
1721 ls->ls_rsbtbl[b].flags &= ~DLM_RTF_SHRINK;
David Teigland05c32f42012-06-14 12:17:32 -05001722 spin_unlock(&ls->ls_rsbtbl[b].lock);
1723
1724 /*
1725 * While searching for rsb's to free, we found some that require
1726 * remote removal. We leave them in place and find them again here
1727 * so there is a very small gap between removing them from the toss
1728 * list and sending the removal. Keeping this gap small is
1729 * important to keep us (the master node) from being out of sync
1730 * with the remote dir node for very long.
1731 *
1732 * From the time the rsb is removed from toss until just after
1733 * send_remove, the rsb name is saved in ls_remove_name. A new
1734 * lookup checks this to ensure that a new lookup message for the
1735 * same resource name is not sent just before the remove message.
1736 */
1737
1738 for (i = 0; i < remote_count; i++) {
1739 name = ls->ls_remove_names[i];
1740 len = ls->ls_remove_lens[i];
1741
1742 spin_lock(&ls->ls_rsbtbl[b].lock);
1743 rv = dlm_search_rsb_tree(&ls->ls_rsbtbl[b].toss, name, len, &r);
1744 if (rv) {
1745 spin_unlock(&ls->ls_rsbtbl[b].lock);
1746 log_debug(ls, "remove_name not toss %s", name);
1747 continue;
1748 }
1749
1750 if (r->res_master_nodeid != our_nodeid) {
1751 spin_unlock(&ls->ls_rsbtbl[b].lock);
1752 log_debug(ls, "remove_name master %d dir %d our %d %s",
1753 r->res_master_nodeid, r->res_dir_nodeid,
1754 our_nodeid, name);
1755 continue;
1756 }
1757
1758 if (r->res_dir_nodeid == our_nodeid) {
1759 /* should never happen */
1760 spin_unlock(&ls->ls_rsbtbl[b].lock);
1761 log_error(ls, "remove_name dir %d master %d our %d %s",
1762 r->res_dir_nodeid, r->res_master_nodeid,
1763 our_nodeid, name);
1764 continue;
1765 }
1766
1767 if (!time_after_eq(jiffies, r->res_toss_time +
1768 dlm_config.ci_toss_secs * HZ)) {
1769 spin_unlock(&ls->ls_rsbtbl[b].lock);
1770 log_debug(ls, "remove_name toss_time %lu now %lu %s",
1771 r->res_toss_time, jiffies, name);
1772 continue;
1773 }
1774
1775 if (!kref_put(&r->res_ref, kill_rsb)) {
1776 spin_unlock(&ls->ls_rsbtbl[b].lock);
1777 log_error(ls, "remove_name in use %s", name);
1778 continue;
1779 }
1780
1781 rb_erase(&r->res_hashnode, &ls->ls_rsbtbl[b].toss);
1782
1783 /* block lookup of same name until we've sent remove */
1784 spin_lock(&ls->ls_remove_spin);
1785 ls->ls_remove_len = len;
1786 memcpy(ls->ls_remove_name, name, DLM_RESNAME_MAXLEN);
1787 spin_unlock(&ls->ls_remove_spin);
1788 spin_unlock(&ls->ls_rsbtbl[b].lock);
1789
1790 send_remove(r);
1791
1792 /* allow lookup of name again */
1793 spin_lock(&ls->ls_remove_spin);
1794 ls->ls_remove_len = 0;
1795 memset(ls->ls_remove_name, 0, DLM_RESNAME_MAXLEN);
1796 spin_unlock(&ls->ls_remove_spin);
1797
1798 dlm_free_rsb(r);
1799 }
David Teiglande7fd4172006-01-18 09:30:29 +00001800}
1801
1802void dlm_scan_rsbs(struct dlm_ls *ls)
1803{
1804 int i;
1805
David Teiglande7fd4172006-01-18 09:30:29 +00001806 for (i = 0; i < ls->ls_rsbtbl_size; i++) {
1807 shrink_bucket(ls, i);
David Teigland85e86ed2007-05-18 08:58:15 -05001808 if (dlm_locking_stopped(ls))
1809 break;
David Teiglande7fd4172006-01-18 09:30:29 +00001810 cond_resched();
1811 }
1812}
1813
David Teigland3ae1acf2007-05-18 08:59:31 -05001814static void add_timeout(struct dlm_lkb *lkb)
1815{
1816 struct dlm_ls *ls = lkb->lkb_resource->res_ls;
1817
David Teiglandeeda4182008-12-09 14:12:21 -06001818 if (is_master_copy(lkb))
David Teigland3ae1acf2007-05-18 08:59:31 -05001819 return;
David Teigland3ae1acf2007-05-18 08:59:31 -05001820
1821 if (test_bit(LSFL_TIMEWARN, &ls->ls_flags) &&
1822 !(lkb->lkb_exflags & DLM_LKF_NODLCKWT)) {
1823 lkb->lkb_flags |= DLM_IFL_WATCH_TIMEWARN;
1824 goto add_it;
1825 }
David Teigland84d8cd62007-05-29 08:44:23 -05001826 if (lkb->lkb_exflags & DLM_LKF_TIMEOUT)
1827 goto add_it;
David Teigland3ae1acf2007-05-18 08:59:31 -05001828 return;
1829
1830 add_it:
1831 DLM_ASSERT(list_empty(&lkb->lkb_time_list), dlm_print_lkb(lkb););
1832 mutex_lock(&ls->ls_timeout_mutex);
1833 hold_lkb(lkb);
David Teigland3ae1acf2007-05-18 08:59:31 -05001834 list_add_tail(&lkb->lkb_time_list, &ls->ls_timeout);
1835 mutex_unlock(&ls->ls_timeout_mutex);
1836}
1837
1838static void del_timeout(struct dlm_lkb *lkb)
1839{
1840 struct dlm_ls *ls = lkb->lkb_resource->res_ls;
1841
1842 mutex_lock(&ls->ls_timeout_mutex);
1843 if (!list_empty(&lkb->lkb_time_list)) {
1844 list_del_init(&lkb->lkb_time_list);
1845 unhold_lkb(lkb);
1846 }
1847 mutex_unlock(&ls->ls_timeout_mutex);
1848}
1849
1850/* FIXME: is it safe to look at lkb_exflags, lkb_flags, lkb_timestamp, and
1851 lkb_lksb_timeout without lock_rsb? Note: we can't lock timeout_mutex
1852 and then lock rsb because of lock ordering in add_timeout. We may need
1853 to specify some special timeout-related bits in the lkb that are just to
1854 be accessed under the timeout_mutex. */
1855
1856void dlm_scan_timeout(struct dlm_ls *ls)
1857{
1858 struct dlm_rsb *r;
1859 struct dlm_lkb *lkb;
1860 int do_cancel, do_warn;
David Teiglandeeda4182008-12-09 14:12:21 -06001861 s64 wait_us;
David Teigland3ae1acf2007-05-18 08:59:31 -05001862
1863 for (;;) {
1864 if (dlm_locking_stopped(ls))
1865 break;
1866
1867 do_cancel = 0;
1868 do_warn = 0;
1869 mutex_lock(&ls->ls_timeout_mutex);
1870 list_for_each_entry(lkb, &ls->ls_timeout, lkb_time_list) {
1871
David Teiglandeeda4182008-12-09 14:12:21 -06001872 wait_us = ktime_to_us(ktime_sub(ktime_get(),
1873 lkb->lkb_timestamp));
1874
David Teigland3ae1acf2007-05-18 08:59:31 -05001875 if ((lkb->lkb_exflags & DLM_LKF_TIMEOUT) &&
David Teiglandeeda4182008-12-09 14:12:21 -06001876 wait_us >= (lkb->lkb_timeout_cs * 10000))
David Teigland3ae1acf2007-05-18 08:59:31 -05001877 do_cancel = 1;
1878
1879 if ((lkb->lkb_flags & DLM_IFL_WATCH_TIMEWARN) &&
David Teiglandeeda4182008-12-09 14:12:21 -06001880 wait_us >= dlm_config.ci_timewarn_cs * 10000)
David Teigland3ae1acf2007-05-18 08:59:31 -05001881 do_warn = 1;
1882
1883 if (!do_cancel && !do_warn)
1884 continue;
1885 hold_lkb(lkb);
1886 break;
1887 }
1888 mutex_unlock(&ls->ls_timeout_mutex);
1889
1890 if (!do_cancel && !do_warn)
1891 break;
1892
1893 r = lkb->lkb_resource;
1894 hold_rsb(r);
1895 lock_rsb(r);
1896
1897 if (do_warn) {
1898 /* clear flag so we only warn once */
1899 lkb->lkb_flags &= ~DLM_IFL_WATCH_TIMEWARN;
1900 if (!(lkb->lkb_exflags & DLM_LKF_TIMEOUT))
1901 del_timeout(lkb);
1902 dlm_timeout_warn(lkb);
1903 }
1904
1905 if (do_cancel) {
Steven Whitehouseb3cab7b2007-05-29 11:14:21 +01001906 log_debug(ls, "timeout cancel %x node %d %s",
David Teigland639aca42007-05-18 16:02:57 -05001907 lkb->lkb_id, lkb->lkb_nodeid, r->res_name);
David Teigland3ae1acf2007-05-18 08:59:31 -05001908 lkb->lkb_flags &= ~DLM_IFL_WATCH_TIMEWARN;
1909 lkb->lkb_flags |= DLM_IFL_TIMEOUT_CANCEL;
1910 del_timeout(lkb);
1911 _cancel_lock(r, lkb);
1912 }
1913
1914 unlock_rsb(r);
1915 unhold_rsb(r);
1916 dlm_put_lkb(lkb);
1917 }
1918}
1919
1920/* This is only called by dlm_recoverd, and we rely on dlm_ls_stop() stopping
1921 dlm_recoverd before checking/setting ls_recover_begin. */
1922
1923void dlm_adjust_timeouts(struct dlm_ls *ls)
1924{
1925 struct dlm_lkb *lkb;
David Teiglandeeda4182008-12-09 14:12:21 -06001926 u64 adj_us = jiffies_to_usecs(jiffies - ls->ls_recover_begin);
David Teigland3ae1acf2007-05-18 08:59:31 -05001927
1928 ls->ls_recover_begin = 0;
1929 mutex_lock(&ls->ls_timeout_mutex);
1930 list_for_each_entry(lkb, &ls->ls_timeout, lkb_time_list)
David Teiglandeeda4182008-12-09 14:12:21 -06001931 lkb->lkb_timestamp = ktime_add_us(lkb->lkb_timestamp, adj_us);
David Teigland3ae1acf2007-05-18 08:59:31 -05001932 mutex_unlock(&ls->ls_timeout_mutex);
David Teiglandc6ff6692011-03-28 14:17:26 -05001933
1934 if (!dlm_config.ci_waitwarn_us)
1935 return;
1936
1937 mutex_lock(&ls->ls_waiters_mutex);
1938 list_for_each_entry(lkb, &ls->ls_waiters, lkb_wait_reply) {
1939 if (ktime_to_us(lkb->lkb_wait_time))
1940 lkb->lkb_wait_time = ktime_get();
1941 }
1942 mutex_unlock(&ls->ls_waiters_mutex);
David Teigland3ae1acf2007-05-18 08:59:31 -05001943}
1944
David Teiglande7fd4172006-01-18 09:30:29 +00001945/* lkb is master or local copy */
1946
1947static void set_lvb_lock(struct dlm_rsb *r, struct dlm_lkb *lkb)
1948{
1949 int b, len = r->res_ls->ls_lvblen;
1950
1951 /* b=1 lvb returned to caller
1952 b=0 lvb written to rsb or invalidated
1953 b=-1 do nothing */
1954
1955 b = dlm_lvb_operations[lkb->lkb_grmode + 1][lkb->lkb_rqmode + 1];
1956
1957 if (b == 1) {
1958 if (!lkb->lkb_lvbptr)
1959 return;
1960
1961 if (!(lkb->lkb_exflags & DLM_LKF_VALBLK))
1962 return;
1963
1964 if (!r->res_lvbptr)
1965 return;
1966
1967 memcpy(lkb->lkb_lvbptr, r->res_lvbptr, len);
1968 lkb->lkb_lvbseq = r->res_lvbseq;
1969
1970 } else if (b == 0) {
1971 if (lkb->lkb_exflags & DLM_LKF_IVVALBLK) {
1972 rsb_set_flag(r, RSB_VALNOTVALID);
1973 return;
1974 }
1975
1976 if (!lkb->lkb_lvbptr)
1977 return;
1978
1979 if (!(lkb->lkb_exflags & DLM_LKF_VALBLK))
1980 return;
1981
1982 if (!r->res_lvbptr)
David Teigland52bda2b2007-11-07 09:06:49 -06001983 r->res_lvbptr = dlm_allocate_lvb(r->res_ls);
David Teiglande7fd4172006-01-18 09:30:29 +00001984
1985 if (!r->res_lvbptr)
1986 return;
1987
1988 memcpy(r->res_lvbptr, lkb->lkb_lvbptr, len);
1989 r->res_lvbseq++;
1990 lkb->lkb_lvbseq = r->res_lvbseq;
1991 rsb_clear_flag(r, RSB_VALNOTVALID);
1992 }
1993
1994 if (rsb_flag(r, RSB_VALNOTVALID))
1995 lkb->lkb_sbflags |= DLM_SBF_VALNOTVALID;
1996}
1997
1998static void set_lvb_unlock(struct dlm_rsb *r, struct dlm_lkb *lkb)
1999{
2000 if (lkb->lkb_grmode < DLM_LOCK_PW)
2001 return;
2002
2003 if (lkb->lkb_exflags & DLM_LKF_IVVALBLK) {
2004 rsb_set_flag(r, RSB_VALNOTVALID);
2005 return;
2006 }
2007
2008 if (!lkb->lkb_lvbptr)
2009 return;
2010
2011 if (!(lkb->lkb_exflags & DLM_LKF_VALBLK))
2012 return;
2013
2014 if (!r->res_lvbptr)
David Teigland52bda2b2007-11-07 09:06:49 -06002015 r->res_lvbptr = dlm_allocate_lvb(r->res_ls);
David Teiglande7fd4172006-01-18 09:30:29 +00002016
2017 if (!r->res_lvbptr)
2018 return;
2019
2020 memcpy(r->res_lvbptr, lkb->lkb_lvbptr, r->res_ls->ls_lvblen);
2021 r->res_lvbseq++;
2022 rsb_clear_flag(r, RSB_VALNOTVALID);
2023}
2024
2025/* lkb is process copy (pc) */
2026
2027static void set_lvb_lock_pc(struct dlm_rsb *r, struct dlm_lkb *lkb,
2028 struct dlm_message *ms)
2029{
2030 int b;
2031
2032 if (!lkb->lkb_lvbptr)
2033 return;
2034
2035 if (!(lkb->lkb_exflags & DLM_LKF_VALBLK))
2036 return;
2037
David Teigland597d0ca2006-07-12 16:44:04 -05002038 b = dlm_lvb_operations[lkb->lkb_grmode + 1][lkb->lkb_rqmode + 1];
David Teiglande7fd4172006-01-18 09:30:29 +00002039 if (b == 1) {
2040 int len = receive_extralen(ms);
Bart Van Asschecfa805f2013-06-26 14:27:57 +02002041 if (len > r->res_ls->ls_lvblen)
2042 len = r->res_ls->ls_lvblen;
David Teiglande7fd4172006-01-18 09:30:29 +00002043 memcpy(lkb->lkb_lvbptr, ms->m_extra, len);
2044 lkb->lkb_lvbseq = ms->m_lvbseq;
2045 }
2046}
2047
2048/* Manipulate lkb's on rsb's convert/granted/waiting queues
2049 remove_lock -- used for unlock, removes lkb from granted
2050 revert_lock -- used for cancel, moves lkb from convert to granted
2051 grant_lock -- used for request and convert, adds lkb to granted or
2052 moves lkb from convert or waiting to granted
2053
2054 Each of these is used for master or local copy lkb's. There is
2055 also a _pc() variation used to make the corresponding change on
2056 a process copy (pc) lkb. */
2057
2058static void _remove_lock(struct dlm_rsb *r, struct dlm_lkb *lkb)
2059{
2060 del_lkb(r, lkb);
2061 lkb->lkb_grmode = DLM_LOCK_IV;
2062 /* this unhold undoes the original ref from create_lkb()
2063 so this leads to the lkb being freed */
2064 unhold_lkb(lkb);
2065}
2066
2067static void remove_lock(struct dlm_rsb *r, struct dlm_lkb *lkb)
2068{
2069 set_lvb_unlock(r, lkb);
2070 _remove_lock(r, lkb);
2071}
2072
2073static void remove_lock_pc(struct dlm_rsb *r, struct dlm_lkb *lkb)
2074{
2075 _remove_lock(r, lkb);
2076}
2077
David Teiglandef0c2bb2007-03-28 09:56:46 -05002078/* returns: 0 did nothing
2079 1 moved lock to granted
2080 -1 removed lock */
2081
2082static int revert_lock(struct dlm_rsb *r, struct dlm_lkb *lkb)
David Teiglande7fd4172006-01-18 09:30:29 +00002083{
David Teiglandef0c2bb2007-03-28 09:56:46 -05002084 int rv = 0;
2085
David Teiglande7fd4172006-01-18 09:30:29 +00002086 lkb->lkb_rqmode = DLM_LOCK_IV;
2087
2088 switch (lkb->lkb_status) {
David Teigland597d0ca2006-07-12 16:44:04 -05002089 case DLM_LKSTS_GRANTED:
2090 break;
David Teiglande7fd4172006-01-18 09:30:29 +00002091 case DLM_LKSTS_CONVERT:
2092 move_lkb(r, lkb, DLM_LKSTS_GRANTED);
David Teiglandef0c2bb2007-03-28 09:56:46 -05002093 rv = 1;
David Teiglande7fd4172006-01-18 09:30:29 +00002094 break;
2095 case DLM_LKSTS_WAITING:
2096 del_lkb(r, lkb);
2097 lkb->lkb_grmode = DLM_LOCK_IV;
2098 /* this unhold undoes the original ref from create_lkb()
2099 so this leads to the lkb being freed */
2100 unhold_lkb(lkb);
David Teiglandef0c2bb2007-03-28 09:56:46 -05002101 rv = -1;
David Teiglande7fd4172006-01-18 09:30:29 +00002102 break;
2103 default:
2104 log_print("invalid status for revert %d", lkb->lkb_status);
2105 }
David Teiglandef0c2bb2007-03-28 09:56:46 -05002106 return rv;
David Teiglande7fd4172006-01-18 09:30:29 +00002107}
2108
David Teiglandef0c2bb2007-03-28 09:56:46 -05002109static int revert_lock_pc(struct dlm_rsb *r, struct dlm_lkb *lkb)
David Teiglande7fd4172006-01-18 09:30:29 +00002110{
David Teiglandef0c2bb2007-03-28 09:56:46 -05002111 return revert_lock(r, lkb);
David Teiglande7fd4172006-01-18 09:30:29 +00002112}
2113
2114static void _grant_lock(struct dlm_rsb *r, struct dlm_lkb *lkb)
2115{
2116 if (lkb->lkb_grmode != lkb->lkb_rqmode) {
2117 lkb->lkb_grmode = lkb->lkb_rqmode;
2118 if (lkb->lkb_status)
2119 move_lkb(r, lkb, DLM_LKSTS_GRANTED);
2120 else
2121 add_lkb(r, lkb, DLM_LKSTS_GRANTED);
2122 }
2123
2124 lkb->lkb_rqmode = DLM_LOCK_IV;
David Teigland48756472012-04-26 15:54:29 -05002125 lkb->lkb_highbast = 0;
David Teiglande7fd4172006-01-18 09:30:29 +00002126}
2127
2128static void grant_lock(struct dlm_rsb *r, struct dlm_lkb *lkb)
2129{
2130 set_lvb_lock(r, lkb);
2131 _grant_lock(r, lkb);
David Teiglande7fd4172006-01-18 09:30:29 +00002132}
2133
2134static void grant_lock_pc(struct dlm_rsb *r, struct dlm_lkb *lkb,
2135 struct dlm_message *ms)
2136{
2137 set_lvb_lock_pc(r, lkb, ms);
2138 _grant_lock(r, lkb);
2139}
2140
2141/* called by grant_pending_locks() which means an async grant message must
2142 be sent to the requesting node in addition to granting the lock if the
2143 lkb belongs to a remote node. */
2144
2145static void grant_lock_pending(struct dlm_rsb *r, struct dlm_lkb *lkb)
2146{
2147 grant_lock(r, lkb);
2148 if (is_master_copy(lkb))
2149 send_grant(r, lkb);
2150 else
2151 queue_cast(r, lkb, 0);
2152}
2153
David Teigland7d3c1fe2007-04-19 10:30:41 -05002154/* The special CONVDEADLK, ALTPR and ALTCW flags allow the master to
2155 change the granted/requested modes. We're munging things accordingly in
2156 the process copy.
2157 CONVDEADLK: our grmode may have been forced down to NL to resolve a
2158 conversion deadlock
2159 ALTPR/ALTCW: our rqmode may have been changed to PR or CW to become
2160 compatible with other granted locks */
2161
David Teigland2a7ce0e2011-04-04 15:19:59 -05002162static void munge_demoted(struct dlm_lkb *lkb)
David Teigland7d3c1fe2007-04-19 10:30:41 -05002163{
David Teigland7d3c1fe2007-04-19 10:30:41 -05002164 if (lkb->lkb_rqmode == DLM_LOCK_IV || lkb->lkb_grmode == DLM_LOCK_IV) {
2165 log_print("munge_demoted %x invalid modes gr %d rq %d",
2166 lkb->lkb_id, lkb->lkb_grmode, lkb->lkb_rqmode);
2167 return;
2168 }
2169
2170 lkb->lkb_grmode = DLM_LOCK_NL;
2171}
2172
2173static void munge_altmode(struct dlm_lkb *lkb, struct dlm_message *ms)
2174{
2175 if (ms->m_type != DLM_MSG_REQUEST_REPLY &&
2176 ms->m_type != DLM_MSG_GRANT) {
2177 log_print("munge_altmode %x invalid reply type %d",
2178 lkb->lkb_id, ms->m_type);
2179 return;
2180 }
2181
2182 if (lkb->lkb_exflags & DLM_LKF_ALTPR)
2183 lkb->lkb_rqmode = DLM_LOCK_PR;
2184 else if (lkb->lkb_exflags & DLM_LKF_ALTCW)
2185 lkb->lkb_rqmode = DLM_LOCK_CW;
2186 else {
2187 log_print("munge_altmode invalid exflags %x", lkb->lkb_exflags);
2188 dlm_print_lkb(lkb);
2189 }
2190}
2191
David Teiglande7fd4172006-01-18 09:30:29 +00002192static inline int first_in_list(struct dlm_lkb *lkb, struct list_head *head)
2193{
2194 struct dlm_lkb *first = list_entry(head->next, struct dlm_lkb,
2195 lkb_statequeue);
2196 if (lkb->lkb_id == first->lkb_id)
David Teigland90135922006-01-20 08:47:07 +00002197 return 1;
David Teiglande7fd4172006-01-18 09:30:29 +00002198
David Teigland90135922006-01-20 08:47:07 +00002199 return 0;
David Teiglande7fd4172006-01-18 09:30:29 +00002200}
2201
David Teiglande7fd4172006-01-18 09:30:29 +00002202/* Check if the given lkb conflicts with another lkb on the queue. */
2203
2204static int queue_conflict(struct list_head *head, struct dlm_lkb *lkb)
2205{
2206 struct dlm_lkb *this;
2207
2208 list_for_each_entry(this, head, lkb_statequeue) {
2209 if (this == lkb)
2210 continue;
David Teigland3bcd3682006-02-23 09:56:38 +00002211 if (!modes_compat(this, lkb))
David Teigland90135922006-01-20 08:47:07 +00002212 return 1;
David Teiglande7fd4172006-01-18 09:30:29 +00002213 }
David Teigland90135922006-01-20 08:47:07 +00002214 return 0;
David Teiglande7fd4172006-01-18 09:30:29 +00002215}
2216
2217/*
2218 * "A conversion deadlock arises with a pair of lock requests in the converting
2219 * queue for one resource. The granted mode of each lock blocks the requested
2220 * mode of the other lock."
2221 *
David Teiglandc85d65e2007-05-18 09:01:26 -05002222 * Part 2: if the granted mode of lkb is preventing an earlier lkb in the
2223 * convert queue from being granted, then deadlk/demote lkb.
David Teiglande7fd4172006-01-18 09:30:29 +00002224 *
2225 * Example:
2226 * Granted Queue: empty
2227 * Convert Queue: NL->EX (first lock)
2228 * PR->EX (second lock)
2229 *
2230 * The first lock can't be granted because of the granted mode of the second
2231 * lock and the second lock can't be granted because it's not first in the
David Teiglandc85d65e2007-05-18 09:01:26 -05002232 * list. We either cancel lkb's conversion (PR->EX) and return EDEADLK, or we
2233 * demote the granted mode of lkb (from PR to NL) if it has the CONVDEADLK
2234 * flag set and return DEMOTED in the lksb flags.
David Teiglande7fd4172006-01-18 09:30:29 +00002235 *
David Teiglandc85d65e2007-05-18 09:01:26 -05002236 * Originally, this function detected conv-deadlk in a more limited scope:
2237 * - if !modes_compat(lkb1, lkb2) && !modes_compat(lkb2, lkb1), or
2238 * - if lkb1 was the first entry in the queue (not just earlier), and was
2239 * blocked by the granted mode of lkb2, and there was nothing on the
2240 * granted queue preventing lkb1 from being granted immediately, i.e.
2241 * lkb2 was the only thing preventing lkb1 from being granted.
2242 *
2243 * That second condition meant we'd only say there was conv-deadlk if
2244 * resolving it (by demotion) would lead to the first lock on the convert
2245 * queue being granted right away. It allowed conversion deadlocks to exist
2246 * between locks on the convert queue while they couldn't be granted anyway.
2247 *
2248 * Now, we detect and take action on conversion deadlocks immediately when
2249 * they're created, even if they may not be immediately consequential. If
2250 * lkb1 exists anywhere in the convert queue and lkb2 comes in with a granted
2251 * mode that would prevent lkb1's conversion from being granted, we do a
2252 * deadlk/demote on lkb2 right away and don't let it onto the convert queue.
2253 * I think this means that the lkb_is_ahead condition below should always
2254 * be zero, i.e. there will never be conv-deadlk between two locks that are
2255 * both already on the convert queue.
David Teiglande7fd4172006-01-18 09:30:29 +00002256 */
2257
David Teiglandc85d65e2007-05-18 09:01:26 -05002258static int conversion_deadlock_detect(struct dlm_rsb *r, struct dlm_lkb *lkb2)
David Teiglande7fd4172006-01-18 09:30:29 +00002259{
David Teiglandc85d65e2007-05-18 09:01:26 -05002260 struct dlm_lkb *lkb1;
2261 int lkb_is_ahead = 0;
David Teiglande7fd4172006-01-18 09:30:29 +00002262
David Teiglandc85d65e2007-05-18 09:01:26 -05002263 list_for_each_entry(lkb1, &r->res_convertqueue, lkb_statequeue) {
2264 if (lkb1 == lkb2) {
2265 lkb_is_ahead = 1;
David Teiglande7fd4172006-01-18 09:30:29 +00002266 continue;
2267 }
2268
David Teiglandc85d65e2007-05-18 09:01:26 -05002269 if (!lkb_is_ahead) {
2270 if (!modes_compat(lkb2, lkb1))
2271 return 1;
2272 } else {
2273 if (!modes_compat(lkb2, lkb1) &&
2274 !modes_compat(lkb1, lkb2))
2275 return 1;
2276 }
David Teiglande7fd4172006-01-18 09:30:29 +00002277 }
David Teigland90135922006-01-20 08:47:07 +00002278 return 0;
David Teiglande7fd4172006-01-18 09:30:29 +00002279}
2280
2281/*
2282 * Return 1 if the lock can be granted, 0 otherwise.
2283 * Also detect and resolve conversion deadlocks.
2284 *
2285 * lkb is the lock to be granted
2286 *
2287 * now is 1 if the function is being called in the context of the
2288 * immediate request, it is 0 if called later, after the lock has been
2289 * queued.
2290 *
David Teiglandc503a622012-06-05 15:55:19 -05002291 * recover is 1 if dlm_recover_grant() is trying to grant conversions
2292 * after recovery.
2293 *
David Teiglande7fd4172006-01-18 09:30:29 +00002294 * References are from chapter 6 of "VAXcluster Principles" by Roy Davis
2295 */
2296
David Teiglandc503a622012-06-05 15:55:19 -05002297static int _can_be_granted(struct dlm_rsb *r, struct dlm_lkb *lkb, int now,
2298 int recover)
David Teiglande7fd4172006-01-18 09:30:29 +00002299{
2300 int8_t conv = (lkb->lkb_grmode != DLM_LOCK_IV);
2301
2302 /*
2303 * 6-10: Version 5.4 introduced an option to address the phenomenon of
2304 * a new request for a NL mode lock being blocked.
2305 *
2306 * 6-11: If the optional EXPEDITE flag is used with the new NL mode
2307 * request, then it would be granted. In essence, the use of this flag
2308 * tells the Lock Manager to expedite theis request by not considering
2309 * what may be in the CONVERTING or WAITING queues... As of this
2310 * writing, the EXPEDITE flag can be used only with new requests for NL
2311 * mode locks. This flag is not valid for conversion requests.
2312 *
2313 * A shortcut. Earlier checks return an error if EXPEDITE is used in a
2314 * conversion or used with a non-NL requested mode. We also know an
2315 * EXPEDITE request is always granted immediately, so now must always
2316 * be 1. The full condition to grant an expedite request: (now &&
2317 * !conv && lkb->rqmode == DLM_LOCK_NL && (flags & EXPEDITE)) can
2318 * therefore be shortened to just checking the flag.
2319 */
2320
2321 if (lkb->lkb_exflags & DLM_LKF_EXPEDITE)
David Teigland90135922006-01-20 08:47:07 +00002322 return 1;
David Teiglande7fd4172006-01-18 09:30:29 +00002323
2324 /*
2325 * A shortcut. Without this, !queue_conflict(grantqueue, lkb) would be
2326 * added to the remaining conditions.
2327 */
2328
2329 if (queue_conflict(&r->res_grantqueue, lkb))
David Teiglandc503a622012-06-05 15:55:19 -05002330 return 0;
David Teiglande7fd4172006-01-18 09:30:29 +00002331
2332 /*
2333 * 6-3: By default, a conversion request is immediately granted if the
2334 * requested mode is compatible with the modes of all other granted
2335 * locks
2336 */
2337
2338 if (queue_conflict(&r->res_convertqueue, lkb))
David Teiglandc503a622012-06-05 15:55:19 -05002339 return 0;
2340
2341 /*
2342 * The RECOVER_GRANT flag means dlm_recover_grant() is granting
2343 * locks for a recovered rsb, on which lkb's have been rebuilt.
2344 * The lkb's may have been rebuilt on the queues in a different
2345 * order than they were in on the previous master. So, granting
2346 * queued conversions in order after recovery doesn't make sense
2347 * since the order hasn't been preserved anyway. The new order
2348 * could also have created a new "in place" conversion deadlock.
2349 * (e.g. old, failed master held granted EX, with PR->EX, NL->EX.
2350 * After recovery, there would be no granted locks, and possibly
2351 * NL->EX, PR->EX, an in-place conversion deadlock.) So, after
2352 * recovery, grant conversions without considering order.
2353 */
2354
2355 if (conv && recover)
2356 return 1;
David Teiglande7fd4172006-01-18 09:30:29 +00002357
2358 /*
2359 * 6-5: But the default algorithm for deciding whether to grant or
2360 * queue conversion requests does not by itself guarantee that such
2361 * requests are serviced on a "first come first serve" basis. This, in
2362 * turn, can lead to a phenomenon known as "indefinate postponement".
2363 *
2364 * 6-7: This issue is dealt with by using the optional QUECVT flag with
2365 * the system service employed to request a lock conversion. This flag
2366 * forces certain conversion requests to be queued, even if they are
2367 * compatible with the granted modes of other locks on the same
2368 * resource. Thus, the use of this flag results in conversion requests
2369 * being ordered on a "first come first servce" basis.
2370 *
2371 * DCT: This condition is all about new conversions being able to occur
2372 * "in place" while the lock remains on the granted queue (assuming
2373 * nothing else conflicts.) IOW if QUECVT isn't set, a conversion
2374 * doesn't _have_ to go onto the convert queue where it's processed in
2375 * order. The "now" variable is necessary to distinguish converts
2376 * being received and processed for the first time now, because once a
2377 * convert is moved to the conversion queue the condition below applies
2378 * requiring fifo granting.
2379 */
2380
2381 if (now && conv && !(lkb->lkb_exflags & DLM_LKF_QUECVT))
David Teigland90135922006-01-20 08:47:07 +00002382 return 1;
David Teiglande7fd4172006-01-18 09:30:29 +00002383
2384 /*
David Teigland53ad1c92012-04-04 09:49:15 -05002385 * Even if the convert is compat with all granted locks,
2386 * QUECVT forces it behind other locks on the convert queue.
2387 */
2388
2389 if (now && conv && (lkb->lkb_exflags & DLM_LKF_QUECVT)) {
2390 if (list_empty(&r->res_convertqueue))
2391 return 1;
2392 else
David Teiglandc503a622012-06-05 15:55:19 -05002393 return 0;
David Teigland53ad1c92012-04-04 09:49:15 -05002394 }
2395
2396 /*
David Teigland3bcd3682006-02-23 09:56:38 +00002397 * The NOORDER flag is set to avoid the standard vms rules on grant
2398 * order.
David Teiglande7fd4172006-01-18 09:30:29 +00002399 */
2400
2401 if (lkb->lkb_exflags & DLM_LKF_NOORDER)
David Teigland90135922006-01-20 08:47:07 +00002402 return 1;
David Teiglande7fd4172006-01-18 09:30:29 +00002403
2404 /*
2405 * 6-3: Once in that queue [CONVERTING], a conversion request cannot be
2406 * granted until all other conversion requests ahead of it are granted
2407 * and/or canceled.
2408 */
2409
2410 if (!now && conv && first_in_list(lkb, &r->res_convertqueue))
David Teigland90135922006-01-20 08:47:07 +00002411 return 1;
David Teiglande7fd4172006-01-18 09:30:29 +00002412
2413 /*
2414 * 6-4: By default, a new request is immediately granted only if all
2415 * three of the following conditions are satisfied when the request is
2416 * issued:
2417 * - The queue of ungranted conversion requests for the resource is
2418 * empty.
2419 * - The queue of ungranted new requests for the resource is empty.
2420 * - The mode of the new request is compatible with the most
2421 * restrictive mode of all granted locks on the resource.
2422 */
2423
2424 if (now && !conv && list_empty(&r->res_convertqueue) &&
2425 list_empty(&r->res_waitqueue))
David Teigland90135922006-01-20 08:47:07 +00002426 return 1;
David Teiglande7fd4172006-01-18 09:30:29 +00002427
2428 /*
2429 * 6-4: Once a lock request is in the queue of ungranted new requests,
2430 * it cannot be granted until the queue of ungranted conversion
2431 * requests is empty, all ungranted new requests ahead of it are
2432 * granted and/or canceled, and it is compatible with the granted mode
2433 * of the most restrictive lock granted on the resource.
2434 */
2435
2436 if (!now && !conv && list_empty(&r->res_convertqueue) &&
2437 first_in_list(lkb, &r->res_waitqueue))
David Teigland90135922006-01-20 08:47:07 +00002438 return 1;
David Teiglandc503a622012-06-05 15:55:19 -05002439
David Teigland90135922006-01-20 08:47:07 +00002440 return 0;
David Teiglande7fd4172006-01-18 09:30:29 +00002441}
2442
David Teiglandc85d65e2007-05-18 09:01:26 -05002443static int can_be_granted(struct dlm_rsb *r, struct dlm_lkb *lkb, int now,
David Teiglandc503a622012-06-05 15:55:19 -05002444 int recover, int *err)
David Teiglande7fd4172006-01-18 09:30:29 +00002445{
David Teiglande7fd4172006-01-18 09:30:29 +00002446 int rv;
2447 int8_t alt = 0, rqmode = lkb->lkb_rqmode;
David Teiglandc85d65e2007-05-18 09:01:26 -05002448 int8_t is_convert = (lkb->lkb_grmode != DLM_LOCK_IV);
2449
2450 if (err)
2451 *err = 0;
David Teiglande7fd4172006-01-18 09:30:29 +00002452
David Teiglandc503a622012-06-05 15:55:19 -05002453 rv = _can_be_granted(r, lkb, now, recover);
David Teiglande7fd4172006-01-18 09:30:29 +00002454 if (rv)
2455 goto out;
2456
David Teiglandc85d65e2007-05-18 09:01:26 -05002457 /*
2458 * The CONVDEADLK flag is non-standard and tells the dlm to resolve
2459 * conversion deadlocks by demoting grmode to NL, otherwise the dlm
2460 * cancels one of the locks.
2461 */
David Teiglande7fd4172006-01-18 09:30:29 +00002462
David Teiglandc85d65e2007-05-18 09:01:26 -05002463 if (is_convert && can_be_queued(lkb) &&
2464 conversion_deadlock_detect(r, lkb)) {
2465 if (lkb->lkb_exflags & DLM_LKF_CONVDEADLK) {
2466 lkb->lkb_grmode = DLM_LOCK_NL;
2467 lkb->lkb_sbflags |= DLM_SBF_DEMOTED;
tsutomu.owa@toshiba.co.jp294e7e42017-09-15 14:17:23 -05002468 } else if (err) {
2469 *err = -EDEADLK;
2470 } else {
2471 log_print("can_be_granted deadlock %x now %d",
2472 lkb->lkb_id, now);
2473 dlm_dump_rsb(r);
David Teiglandc85d65e2007-05-18 09:01:26 -05002474 }
2475 goto out;
2476 }
2477
2478 /*
2479 * The ALTPR and ALTCW flags are non-standard and tell the dlm to try
2480 * to grant a request in a mode other than the normal rqmode. It's a
2481 * simple way to provide a big optimization to applications that can
2482 * use them.
2483 */
2484
2485 if (rqmode != DLM_LOCK_PR && (lkb->lkb_exflags & DLM_LKF_ALTPR))
David Teiglande7fd4172006-01-18 09:30:29 +00002486 alt = DLM_LOCK_PR;
David Teiglandc85d65e2007-05-18 09:01:26 -05002487 else if (rqmode != DLM_LOCK_CW && (lkb->lkb_exflags & DLM_LKF_ALTCW))
David Teiglande7fd4172006-01-18 09:30:29 +00002488 alt = DLM_LOCK_CW;
2489
2490 if (alt) {
2491 lkb->lkb_rqmode = alt;
David Teiglandc503a622012-06-05 15:55:19 -05002492 rv = _can_be_granted(r, lkb, now, 0);
David Teiglande7fd4172006-01-18 09:30:29 +00002493 if (rv)
2494 lkb->lkb_sbflags |= DLM_SBF_ALTMODE;
2495 else
2496 lkb->lkb_rqmode = rqmode;
2497 }
2498 out:
2499 return rv;
2500}
2501
David Teigland36509252007-08-07 09:44:48 -05002502/* Returns the highest requested mode of all blocked conversions; sets
2503 cw if there's a blocked conversion to DLM_LOCK_CW. */
David Teiglandc85d65e2007-05-18 09:01:26 -05002504
David Teigland48756472012-04-26 15:54:29 -05002505static int grant_pending_convert(struct dlm_rsb *r, int high, int *cw,
2506 unsigned int *count)
David Teiglande7fd4172006-01-18 09:30:29 +00002507{
2508 struct dlm_lkb *lkb, *s;
David Teiglandc503a622012-06-05 15:55:19 -05002509 int recover = rsb_flag(r, RSB_RECOVER_GRANT);
David Teiglande7fd4172006-01-18 09:30:29 +00002510 int hi, demoted, quit, grant_restart, demote_restart;
David Teiglandc85d65e2007-05-18 09:01:26 -05002511 int deadlk;
David Teiglande7fd4172006-01-18 09:30:29 +00002512
2513 quit = 0;
2514 restart:
2515 grant_restart = 0;
2516 demote_restart = 0;
2517 hi = DLM_LOCK_IV;
2518
2519 list_for_each_entry_safe(lkb, s, &r->res_convertqueue, lkb_statequeue) {
2520 demoted = is_demoted(lkb);
David Teiglandc85d65e2007-05-18 09:01:26 -05002521 deadlk = 0;
2522
David Teiglandc503a622012-06-05 15:55:19 -05002523 if (can_be_granted(r, lkb, 0, recover, &deadlk)) {
David Teiglande7fd4172006-01-18 09:30:29 +00002524 grant_lock_pending(r, lkb);
2525 grant_restart = 1;
David Teigland48756472012-04-26 15:54:29 -05002526 if (count)
2527 (*count)++;
David Teiglandc85d65e2007-05-18 09:01:26 -05002528 continue;
David Teiglande7fd4172006-01-18 09:30:29 +00002529 }
David Teiglandc85d65e2007-05-18 09:01:26 -05002530
2531 if (!demoted && is_demoted(lkb)) {
2532 log_print("WARN: pending demoted %x node %d %s",
2533 lkb->lkb_id, lkb->lkb_nodeid, r->res_name);
2534 demote_restart = 1;
2535 continue;
2536 }
2537
2538 if (deadlk) {
tsutomu.owa@toshiba.co.jp294e7e42017-09-15 14:17:23 -05002539 /*
2540 * If DLM_LKB_NODLKWT flag is set and conversion
2541 * deadlock is detected, we request blocking AST and
2542 * down (or cancel) conversion.
2543 */
2544 if (lkb->lkb_exflags & DLM_LKF_NODLCKWT) {
2545 if (lkb->lkb_highbast < lkb->lkb_rqmode) {
2546 queue_bast(r, lkb, lkb->lkb_rqmode);
2547 lkb->lkb_highbast = lkb->lkb_rqmode;
2548 }
2549 } else {
2550 log_print("WARN: pending deadlock %x node %d %s",
2551 lkb->lkb_id, lkb->lkb_nodeid,
2552 r->res_name);
2553 dlm_dump_rsb(r);
2554 }
David Teiglandc85d65e2007-05-18 09:01:26 -05002555 continue;
2556 }
2557
2558 hi = max_t(int, lkb->lkb_rqmode, hi);
David Teigland36509252007-08-07 09:44:48 -05002559
2560 if (cw && lkb->lkb_rqmode == DLM_LOCK_CW)
2561 *cw = 1;
David Teiglande7fd4172006-01-18 09:30:29 +00002562 }
2563
2564 if (grant_restart)
2565 goto restart;
2566 if (demote_restart && !quit) {
2567 quit = 1;
2568 goto restart;
2569 }
2570
2571 return max_t(int, high, hi);
2572}
2573
David Teigland48756472012-04-26 15:54:29 -05002574static int grant_pending_wait(struct dlm_rsb *r, int high, int *cw,
2575 unsigned int *count)
David Teiglande7fd4172006-01-18 09:30:29 +00002576{
2577 struct dlm_lkb *lkb, *s;
2578
2579 list_for_each_entry_safe(lkb, s, &r->res_waitqueue, lkb_statequeue) {
David Teiglandc503a622012-06-05 15:55:19 -05002580 if (can_be_granted(r, lkb, 0, 0, NULL)) {
David Teiglande7fd4172006-01-18 09:30:29 +00002581 grant_lock_pending(r, lkb);
David Teigland48756472012-04-26 15:54:29 -05002582 if (count)
2583 (*count)++;
2584 } else {
David Teiglande7fd4172006-01-18 09:30:29 +00002585 high = max_t(int, lkb->lkb_rqmode, high);
David Teigland36509252007-08-07 09:44:48 -05002586 if (lkb->lkb_rqmode == DLM_LOCK_CW)
2587 *cw = 1;
2588 }
David Teiglande7fd4172006-01-18 09:30:29 +00002589 }
2590
2591 return high;
2592}
2593
David Teigland36509252007-08-07 09:44:48 -05002594/* cw of 1 means there's a lock with a rqmode of DLM_LOCK_CW that's blocked
2595 on either the convert or waiting queue.
2596 high is the largest rqmode of all locks blocked on the convert or
2597 waiting queue. */
2598
2599static int lock_requires_bast(struct dlm_lkb *gr, int high, int cw)
2600{
2601 if (gr->lkb_grmode == DLM_LOCK_PR && cw) {
2602 if (gr->lkb_highbast < DLM_LOCK_EX)
2603 return 1;
2604 return 0;
2605 }
2606
2607 if (gr->lkb_highbast < high &&
2608 !__dlm_compat_matrix[gr->lkb_grmode+1][high+1])
2609 return 1;
2610 return 0;
2611}
2612
David Teigland48756472012-04-26 15:54:29 -05002613static void grant_pending_locks(struct dlm_rsb *r, unsigned int *count)
David Teiglande7fd4172006-01-18 09:30:29 +00002614{
2615 struct dlm_lkb *lkb, *s;
2616 int high = DLM_LOCK_IV;
David Teigland36509252007-08-07 09:44:48 -05002617 int cw = 0;
David Teiglande7fd4172006-01-18 09:30:29 +00002618
David Teigland48756472012-04-26 15:54:29 -05002619 if (!is_master(r)) {
2620 log_print("grant_pending_locks r nodeid %d", r->res_nodeid);
2621 dlm_dump_rsb(r);
2622 return;
2623 }
David Teiglande7fd4172006-01-18 09:30:29 +00002624
David Teigland48756472012-04-26 15:54:29 -05002625 high = grant_pending_convert(r, high, &cw, count);
2626 high = grant_pending_wait(r, high, &cw, count);
David Teiglande7fd4172006-01-18 09:30:29 +00002627
2628 if (high == DLM_LOCK_IV)
2629 return;
2630
2631 /*
2632 * If there are locks left on the wait/convert queue then send blocking
2633 * ASTs to granted locks based on the largest requested mode (high)
David Teigland36509252007-08-07 09:44:48 -05002634 * found above.
David Teiglande7fd4172006-01-18 09:30:29 +00002635 */
2636
2637 list_for_each_entry_safe(lkb, s, &r->res_grantqueue, lkb_statequeue) {
David Teiglande5dae542008-02-06 00:35:45 -06002638 if (lkb->lkb_bastfn && lock_requires_bast(lkb, high, cw)) {
David Teigland329fc4c2008-05-20 12:18:10 -05002639 if (cw && high == DLM_LOCK_PR &&
2640 lkb->lkb_grmode == DLM_LOCK_PR)
David Teigland36509252007-08-07 09:44:48 -05002641 queue_bast(r, lkb, DLM_LOCK_CW);
2642 else
2643 queue_bast(r, lkb, high);
David Teiglande7fd4172006-01-18 09:30:29 +00002644 lkb->lkb_highbast = high;
2645 }
2646 }
2647}
2648
David Teigland36509252007-08-07 09:44:48 -05002649static int modes_require_bast(struct dlm_lkb *gr, struct dlm_lkb *rq)
2650{
2651 if ((gr->lkb_grmode == DLM_LOCK_PR && rq->lkb_rqmode == DLM_LOCK_CW) ||
2652 (gr->lkb_grmode == DLM_LOCK_CW && rq->lkb_rqmode == DLM_LOCK_PR)) {
2653 if (gr->lkb_highbast < DLM_LOCK_EX)
2654 return 1;
2655 return 0;
2656 }
2657
2658 if (gr->lkb_highbast < rq->lkb_rqmode && !modes_compat(gr, rq))
2659 return 1;
2660 return 0;
2661}
2662
David Teiglande7fd4172006-01-18 09:30:29 +00002663static void send_bast_queue(struct dlm_rsb *r, struct list_head *head,
2664 struct dlm_lkb *lkb)
2665{
2666 struct dlm_lkb *gr;
2667
2668 list_for_each_entry(gr, head, lkb_statequeue) {
Steven Whitehouse314dd2a2010-09-03 10:07:48 -05002669 /* skip self when sending basts to convertqueue */
2670 if (gr == lkb)
2671 continue;
David Teiglande5dae542008-02-06 00:35:45 -06002672 if (gr->lkb_bastfn && modes_require_bast(gr, lkb)) {
David Teiglande7fd4172006-01-18 09:30:29 +00002673 queue_bast(r, gr, lkb->lkb_rqmode);
2674 gr->lkb_highbast = lkb->lkb_rqmode;
2675 }
2676 }
2677}
2678
2679static void send_blocking_asts(struct dlm_rsb *r, struct dlm_lkb *lkb)
2680{
2681 send_bast_queue(r, &r->res_grantqueue, lkb);
2682}
2683
2684static void send_blocking_asts_all(struct dlm_rsb *r, struct dlm_lkb *lkb)
2685{
2686 send_bast_queue(r, &r->res_grantqueue, lkb);
2687 send_bast_queue(r, &r->res_convertqueue, lkb);
2688}
2689
2690/* set_master(r, lkb) -- set the master nodeid of a resource
2691
2692 The purpose of this function is to set the nodeid field in the given
2693 lkb using the nodeid field in the given rsb. If the rsb's nodeid is
2694 known, it can just be copied to the lkb and the function will return
2695 0. If the rsb's nodeid is _not_ known, it needs to be looked up
2696 before it can be copied to the lkb.
2697
2698 When the rsb nodeid is being looked up remotely, the initial lkb
2699 causing the lookup is kept on the ls_waiters list waiting for the
2700 lookup reply. Other lkb's waiting for the same rsb lookup are kept
2701 on the rsb's res_lookup list until the master is verified.
2702
2703 Return values:
2704 0: nodeid is set in rsb/lkb and the caller should go ahead and use it
2705 1: the rsb master is not available and the lkb has been placed on
2706 a wait queue
2707*/
2708
2709static int set_master(struct dlm_rsb *r, struct dlm_lkb *lkb)
2710{
David Teiglandc04fecb2012-05-10 10:18:07 -05002711 int our_nodeid = dlm_our_nodeid();
David Teiglande7fd4172006-01-18 09:30:29 +00002712
2713 if (rsb_flag(r, RSB_MASTER_UNCERTAIN)) {
2714 rsb_clear_flag(r, RSB_MASTER_UNCERTAIN);
2715 r->res_first_lkid = lkb->lkb_id;
2716 lkb->lkb_nodeid = r->res_nodeid;
2717 return 0;
2718 }
2719
2720 if (r->res_first_lkid && r->res_first_lkid != lkb->lkb_id) {
2721 list_add_tail(&lkb->lkb_rsb_lookup, &r->res_lookup);
2722 return 1;
2723 }
2724
David Teiglandc04fecb2012-05-10 10:18:07 -05002725 if (r->res_master_nodeid == our_nodeid) {
David Teiglande7fd4172006-01-18 09:30:29 +00002726 lkb->lkb_nodeid = 0;
2727 return 0;
2728 }
2729
David Teiglandc04fecb2012-05-10 10:18:07 -05002730 if (r->res_master_nodeid) {
2731 lkb->lkb_nodeid = r->res_master_nodeid;
David Teiglande7fd4172006-01-18 09:30:29 +00002732 return 0;
2733 }
2734
David Teiglandc04fecb2012-05-10 10:18:07 -05002735 if (dlm_dir_nodeid(r) == our_nodeid) {
2736 /* This is a somewhat unusual case; find_rsb will usually
2737 have set res_master_nodeid when dir nodeid is local, but
2738 there are cases where we become the dir node after we've
2739 past find_rsb and go through _request_lock again.
2740 confirm_master() or process_lookup_list() needs to be
2741 called after this. */
2742 log_debug(r->res_ls, "set_master %x self master %d dir %d %s",
2743 lkb->lkb_id, r->res_master_nodeid, r->res_dir_nodeid,
2744 r->res_name);
2745 r->res_master_nodeid = our_nodeid;
David Teiglande7fd4172006-01-18 09:30:29 +00002746 r->res_nodeid = 0;
2747 lkb->lkb_nodeid = 0;
David Teiglandc04fecb2012-05-10 10:18:07 -05002748 return 0;
David Teiglande7fd4172006-01-18 09:30:29 +00002749 }
David Teiglandc04fecb2012-05-10 10:18:07 -05002750
David Teigland05c32f42012-06-14 12:17:32 -05002751 wait_pending_remove(r);
2752
David Teiglandc04fecb2012-05-10 10:18:07 -05002753 r->res_first_lkid = lkb->lkb_id;
2754 send_lookup(r, lkb);
2755 return 1;
David Teiglande7fd4172006-01-18 09:30:29 +00002756}
2757
2758static void process_lookup_list(struct dlm_rsb *r)
2759{
2760 struct dlm_lkb *lkb, *safe;
2761
2762 list_for_each_entry_safe(lkb, safe, &r->res_lookup, lkb_rsb_lookup) {
David Teiglandef0c2bb2007-03-28 09:56:46 -05002763 list_del_init(&lkb->lkb_rsb_lookup);
David Teiglande7fd4172006-01-18 09:30:29 +00002764 _request_lock(r, lkb);
2765 schedule();
2766 }
2767}
2768
2769/* confirm_master -- confirm (or deny) an rsb's master nodeid */
2770
2771static void confirm_master(struct dlm_rsb *r, int error)
2772{
2773 struct dlm_lkb *lkb;
2774
2775 if (!r->res_first_lkid)
2776 return;
2777
2778 switch (error) {
2779 case 0:
2780 case -EINPROGRESS:
2781 r->res_first_lkid = 0;
2782 process_lookup_list(r);
2783 break;
2784
2785 case -EAGAIN:
David Teiglandaec64e12008-01-08 15:37:47 -06002786 case -EBADR:
2787 case -ENOTBLK:
2788 /* the remote request failed and won't be retried (it was
2789 a NOQUEUE, or has been canceled/unlocked); make a waiting
2790 lkb the first_lkid */
David Teiglande7fd4172006-01-18 09:30:29 +00002791
2792 r->res_first_lkid = 0;
2793
2794 if (!list_empty(&r->res_lookup)) {
2795 lkb = list_entry(r->res_lookup.next, struct dlm_lkb,
2796 lkb_rsb_lookup);
David Teiglandef0c2bb2007-03-28 09:56:46 -05002797 list_del_init(&lkb->lkb_rsb_lookup);
David Teiglande7fd4172006-01-18 09:30:29 +00002798 r->res_first_lkid = lkb->lkb_id;
2799 _request_lock(r, lkb);
David Teigland761b9d32008-02-21 11:25:42 -06002800 }
David Teiglande7fd4172006-01-18 09:30:29 +00002801 break;
2802
2803 default:
2804 log_error(r->res_ls, "confirm_master unknown error %d", error);
2805 }
2806}
2807
2808static int set_lock_args(int mode, struct dlm_lksb *lksb, uint32_t flags,
David Teiglande5dae542008-02-06 00:35:45 -06002809 int namelen, unsigned long timeout_cs,
2810 void (*ast) (void *astparam),
2811 void *astparam,
2812 void (*bast) (void *astparam, int mode),
2813 struct dlm_args *args)
David Teiglande7fd4172006-01-18 09:30:29 +00002814{
2815 int rv = -EINVAL;
2816
2817 /* check for invalid arg usage */
2818
2819 if (mode < 0 || mode > DLM_LOCK_EX)
2820 goto out;
2821
2822 if (!(flags & DLM_LKF_CONVERT) && (namelen > DLM_RESNAME_MAXLEN))
2823 goto out;
2824
2825 if (flags & DLM_LKF_CANCEL)
2826 goto out;
2827
2828 if (flags & DLM_LKF_QUECVT && !(flags & DLM_LKF_CONVERT))
2829 goto out;
2830
2831 if (flags & DLM_LKF_CONVDEADLK && !(flags & DLM_LKF_CONVERT))
2832 goto out;
2833
2834 if (flags & DLM_LKF_CONVDEADLK && flags & DLM_LKF_NOQUEUE)
2835 goto out;
2836
2837 if (flags & DLM_LKF_EXPEDITE && flags & DLM_LKF_CONVERT)
2838 goto out;
2839
2840 if (flags & DLM_LKF_EXPEDITE && flags & DLM_LKF_QUECVT)
2841 goto out;
2842
2843 if (flags & DLM_LKF_EXPEDITE && flags & DLM_LKF_NOQUEUE)
2844 goto out;
2845
2846 if (flags & DLM_LKF_EXPEDITE && mode != DLM_LOCK_NL)
2847 goto out;
2848
2849 if (!ast || !lksb)
2850 goto out;
2851
2852 if (flags & DLM_LKF_VALBLK && !lksb->sb_lvbptr)
2853 goto out;
2854
David Teiglande7fd4172006-01-18 09:30:29 +00002855 if (flags & DLM_LKF_CONVERT && !lksb->sb_lkid)
2856 goto out;
2857
2858 /* these args will be copied to the lkb in validate_lock_args,
2859 it cannot be done now because when converting locks, fields in
2860 an active lkb cannot be modified before locking the rsb */
2861
2862 args->flags = flags;
David Teiglande5dae542008-02-06 00:35:45 -06002863 args->astfn = ast;
2864 args->astparam = astparam;
2865 args->bastfn = bast;
David Teiglandd7db9232007-05-18 09:00:32 -05002866 args->timeout = timeout_cs;
David Teiglande7fd4172006-01-18 09:30:29 +00002867 args->mode = mode;
2868 args->lksb = lksb;
David Teiglande7fd4172006-01-18 09:30:29 +00002869 rv = 0;
2870 out:
2871 return rv;
2872}
2873
2874static int set_unlock_args(uint32_t flags, void *astarg, struct dlm_args *args)
2875{
2876 if (flags & ~(DLM_LKF_CANCEL | DLM_LKF_VALBLK | DLM_LKF_IVVALBLK |
2877 DLM_LKF_FORCEUNLOCK))
2878 return -EINVAL;
2879
David Teiglandef0c2bb2007-03-28 09:56:46 -05002880 if (flags & DLM_LKF_CANCEL && flags & DLM_LKF_FORCEUNLOCK)
2881 return -EINVAL;
2882
David Teiglande7fd4172006-01-18 09:30:29 +00002883 args->flags = flags;
David Teiglande5dae542008-02-06 00:35:45 -06002884 args->astparam = astarg;
David Teiglande7fd4172006-01-18 09:30:29 +00002885 return 0;
2886}
2887
2888static int validate_lock_args(struct dlm_ls *ls, struct dlm_lkb *lkb,
2889 struct dlm_args *args)
2890{
2891 int rv = -EINVAL;
2892
2893 if (args->flags & DLM_LKF_CONVERT) {
2894 if (lkb->lkb_flags & DLM_IFL_MSTCPY)
2895 goto out;
2896
2897 if (args->flags & DLM_LKF_QUECVT &&
2898 !__quecvt_compat_matrix[lkb->lkb_grmode+1][args->mode+1])
2899 goto out;
2900
2901 rv = -EBUSY;
2902 if (lkb->lkb_status != DLM_LKSTS_GRANTED)
2903 goto out;
2904
2905 if (lkb->lkb_wait_type)
2906 goto out;
David Teiglandef0c2bb2007-03-28 09:56:46 -05002907
2908 if (is_overlap(lkb))
2909 goto out;
David Teiglande7fd4172006-01-18 09:30:29 +00002910 }
2911
2912 lkb->lkb_exflags = args->flags;
2913 lkb->lkb_sbflags = 0;
David Teiglande5dae542008-02-06 00:35:45 -06002914 lkb->lkb_astfn = args->astfn;
David Teiglande7fd4172006-01-18 09:30:29 +00002915 lkb->lkb_astparam = args->astparam;
David Teiglande5dae542008-02-06 00:35:45 -06002916 lkb->lkb_bastfn = args->bastfn;
David Teiglande7fd4172006-01-18 09:30:29 +00002917 lkb->lkb_rqmode = args->mode;
2918 lkb->lkb_lksb = args->lksb;
2919 lkb->lkb_lvbptr = args->lksb->sb_lvbptr;
2920 lkb->lkb_ownpid = (int) current->pid;
David Teiglandd7db9232007-05-18 09:00:32 -05002921 lkb->lkb_timeout_cs = args->timeout;
David Teiglande7fd4172006-01-18 09:30:29 +00002922 rv = 0;
2923 out:
David Teigland43279e52009-01-28 14:37:54 -06002924 if (rv)
2925 log_debug(ls, "validate_lock_args %d %x %x %x %d %d %s",
2926 rv, lkb->lkb_id, lkb->lkb_flags, args->flags,
2927 lkb->lkb_status, lkb->lkb_wait_type,
2928 lkb->lkb_resource->res_name);
David Teiglande7fd4172006-01-18 09:30:29 +00002929 return rv;
2930}
2931
David Teiglandef0c2bb2007-03-28 09:56:46 -05002932/* when dlm_unlock() sees -EBUSY with CANCEL/FORCEUNLOCK it returns 0
2933 for success */
2934
2935/* note: it's valid for lkb_nodeid/res_nodeid to be -1 when we get here
2936 because there may be a lookup in progress and it's valid to do
2937 cancel/unlockf on it */
2938
David Teiglande7fd4172006-01-18 09:30:29 +00002939static int validate_unlock_args(struct dlm_lkb *lkb, struct dlm_args *args)
2940{
David Teiglandef0c2bb2007-03-28 09:56:46 -05002941 struct dlm_ls *ls = lkb->lkb_resource->res_ls;
David Teiglande7fd4172006-01-18 09:30:29 +00002942 int rv = -EINVAL;
2943
David Teiglandef0c2bb2007-03-28 09:56:46 -05002944 if (lkb->lkb_flags & DLM_IFL_MSTCPY) {
2945 log_error(ls, "unlock on MSTCPY %x", lkb->lkb_id);
2946 dlm_print_lkb(lkb);
David Teiglande7fd4172006-01-18 09:30:29 +00002947 goto out;
David Teiglandef0c2bb2007-03-28 09:56:46 -05002948 }
David Teiglande7fd4172006-01-18 09:30:29 +00002949
David Teiglandef0c2bb2007-03-28 09:56:46 -05002950 /* an lkb may still exist even though the lock is EOL'ed due to a
2951 cancel, unlock or failed noqueue request; an app can't use these
2952 locks; return same error as if the lkid had not been found at all */
2953
2954 if (lkb->lkb_flags & DLM_IFL_ENDOFLIFE) {
2955 log_debug(ls, "unlock on ENDOFLIFE %x", lkb->lkb_id);
2956 rv = -ENOENT;
2957 goto out;
2958 }
2959
2960 /* an lkb may be waiting for an rsb lookup to complete where the
2961 lookup was initiated by another lock */
2962
David Teigland42dc1602008-01-09 10:30:45 -06002963 if (!list_empty(&lkb->lkb_rsb_lookup)) {
2964 if (args->flags & (DLM_LKF_CANCEL | DLM_LKF_FORCEUNLOCK)) {
David Teiglandef0c2bb2007-03-28 09:56:46 -05002965 log_debug(ls, "unlock on rsb_lookup %x", lkb->lkb_id);
2966 list_del_init(&lkb->lkb_rsb_lookup);
2967 queue_cast(lkb->lkb_resource, lkb,
2968 args->flags & DLM_LKF_CANCEL ?
2969 -DLM_ECANCEL : -DLM_EUNLOCK);
2970 unhold_lkb(lkb); /* undoes create_lkb() */
David Teiglandef0c2bb2007-03-28 09:56:46 -05002971 }
David Teigland42dc1602008-01-09 10:30:45 -06002972 /* caller changes -EBUSY to 0 for CANCEL and FORCEUNLOCK */
2973 rv = -EBUSY;
2974 goto out;
David Teiglandef0c2bb2007-03-28 09:56:46 -05002975 }
2976
2977 /* cancel not allowed with another cancel/unlock in progress */
2978
2979 if (args->flags & DLM_LKF_CANCEL) {
2980 if (lkb->lkb_exflags & DLM_LKF_CANCEL)
2981 goto out;
2982
2983 if (is_overlap(lkb))
2984 goto out;
2985
David Teigland3ae1acf2007-05-18 08:59:31 -05002986 /* don't let scand try to do a cancel */
2987 del_timeout(lkb);
2988
David Teiglandef0c2bb2007-03-28 09:56:46 -05002989 if (lkb->lkb_flags & DLM_IFL_RESEND) {
2990 lkb->lkb_flags |= DLM_IFL_OVERLAP_CANCEL;
2991 rv = -EBUSY;
2992 goto out;
2993 }
2994
David Teiglanda536e382009-02-27 15:23:28 -06002995 /* there's nothing to cancel */
2996 if (lkb->lkb_status == DLM_LKSTS_GRANTED &&
2997 !lkb->lkb_wait_type) {
2998 rv = -EBUSY;
2999 goto out;
3000 }
3001
David Teiglandef0c2bb2007-03-28 09:56:46 -05003002 switch (lkb->lkb_wait_type) {
3003 case DLM_MSG_LOOKUP:
3004 case DLM_MSG_REQUEST:
3005 lkb->lkb_flags |= DLM_IFL_OVERLAP_CANCEL;
3006 rv = -EBUSY;
3007 goto out;
3008 case DLM_MSG_UNLOCK:
3009 case DLM_MSG_CANCEL:
3010 goto out;
3011 }
3012 /* add_to_waiters() will set OVERLAP_CANCEL */
David Teiglande7fd4172006-01-18 09:30:29 +00003013 goto out_ok;
David Teiglandef0c2bb2007-03-28 09:56:46 -05003014 }
David Teiglande7fd4172006-01-18 09:30:29 +00003015
David Teiglandef0c2bb2007-03-28 09:56:46 -05003016 /* do we need to allow a force-unlock if there's a normal unlock
3017 already in progress? in what conditions could the normal unlock
3018 fail such that we'd want to send a force-unlock to be sure? */
David Teiglande7fd4172006-01-18 09:30:29 +00003019
David Teiglandef0c2bb2007-03-28 09:56:46 -05003020 if (args->flags & DLM_LKF_FORCEUNLOCK) {
3021 if (lkb->lkb_exflags & DLM_LKF_FORCEUNLOCK)
3022 goto out;
David Teiglande7fd4172006-01-18 09:30:29 +00003023
David Teiglandef0c2bb2007-03-28 09:56:46 -05003024 if (is_overlap_unlock(lkb))
3025 goto out;
3026
David Teigland3ae1acf2007-05-18 08:59:31 -05003027 /* don't let scand try to do a cancel */
3028 del_timeout(lkb);
3029
David Teiglandef0c2bb2007-03-28 09:56:46 -05003030 if (lkb->lkb_flags & DLM_IFL_RESEND) {
3031 lkb->lkb_flags |= DLM_IFL_OVERLAP_UNLOCK;
3032 rv = -EBUSY;
3033 goto out;
3034 }
3035
3036 switch (lkb->lkb_wait_type) {
3037 case DLM_MSG_LOOKUP:
3038 case DLM_MSG_REQUEST:
3039 lkb->lkb_flags |= DLM_IFL_OVERLAP_UNLOCK;
3040 rv = -EBUSY;
3041 goto out;
3042 case DLM_MSG_UNLOCK:
3043 goto out;
3044 }
3045 /* add_to_waiters() will set OVERLAP_UNLOCK */
3046 goto out_ok;
3047 }
3048
3049 /* normal unlock not allowed if there's any op in progress */
David Teiglande7fd4172006-01-18 09:30:29 +00003050 rv = -EBUSY;
David Teiglandef0c2bb2007-03-28 09:56:46 -05003051 if (lkb->lkb_wait_type || lkb->lkb_wait_count)
David Teiglande7fd4172006-01-18 09:30:29 +00003052 goto out;
3053
3054 out_ok:
David Teiglandef0c2bb2007-03-28 09:56:46 -05003055 /* an overlapping op shouldn't blow away exflags from other op */
3056 lkb->lkb_exflags |= args->flags;
David Teiglande7fd4172006-01-18 09:30:29 +00003057 lkb->lkb_sbflags = 0;
3058 lkb->lkb_astparam = args->astparam;
David Teiglande7fd4172006-01-18 09:30:29 +00003059 rv = 0;
3060 out:
David Teiglandef0c2bb2007-03-28 09:56:46 -05003061 if (rv)
3062 log_debug(ls, "validate_unlock_args %d %x %x %x %x %d %s", rv,
3063 lkb->lkb_id, lkb->lkb_flags, lkb->lkb_exflags,
3064 args->flags, lkb->lkb_wait_type,
3065 lkb->lkb_resource->res_name);
David Teiglande7fd4172006-01-18 09:30:29 +00003066 return rv;
3067}
3068
3069/*
3070 * Four stage 4 varieties:
3071 * do_request(), do_convert(), do_unlock(), do_cancel()
3072 * These are called on the master node for the given lock and
3073 * from the central locking logic.
3074 */
3075
3076static int do_request(struct dlm_rsb *r, struct dlm_lkb *lkb)
3077{
3078 int error = 0;
3079
David Teiglandc503a622012-06-05 15:55:19 -05003080 if (can_be_granted(r, lkb, 1, 0, NULL)) {
David Teiglande7fd4172006-01-18 09:30:29 +00003081 grant_lock(r, lkb);
3082 queue_cast(r, lkb, 0);
3083 goto out;
3084 }
3085
3086 if (can_be_queued(lkb)) {
3087 error = -EINPROGRESS;
3088 add_lkb(r, lkb, DLM_LKSTS_WAITING);
David Teigland3ae1acf2007-05-18 08:59:31 -05003089 add_timeout(lkb);
David Teiglande7fd4172006-01-18 09:30:29 +00003090 goto out;
3091 }
3092
3093 error = -EAGAIN;
David Teiglande7fd4172006-01-18 09:30:29 +00003094 queue_cast(r, lkb, -EAGAIN);
David Teiglande7fd4172006-01-18 09:30:29 +00003095 out:
3096 return error;
3097}
3098
David Teiglandcf6620a2010-02-24 11:59:23 -06003099static void do_request_effects(struct dlm_rsb *r, struct dlm_lkb *lkb,
3100 int error)
3101{
3102 switch (error) {
3103 case -EAGAIN:
3104 if (force_blocking_asts(lkb))
3105 send_blocking_asts_all(r, lkb);
3106 break;
3107 case -EINPROGRESS:
3108 send_blocking_asts(r, lkb);
3109 break;
3110 }
3111}
3112
David Teiglande7fd4172006-01-18 09:30:29 +00003113static int do_convert(struct dlm_rsb *r, struct dlm_lkb *lkb)
3114{
3115 int error = 0;
David Teiglandc85d65e2007-05-18 09:01:26 -05003116 int deadlk = 0;
David Teiglande7fd4172006-01-18 09:30:29 +00003117
3118 /* changing an existing lock may allow others to be granted */
3119
David Teiglandc503a622012-06-05 15:55:19 -05003120 if (can_be_granted(r, lkb, 1, 0, &deadlk)) {
David Teiglande7fd4172006-01-18 09:30:29 +00003121 grant_lock(r, lkb);
3122 queue_cast(r, lkb, 0);
David Teiglande7fd4172006-01-18 09:30:29 +00003123 goto out;
3124 }
3125
David Teiglandc85d65e2007-05-18 09:01:26 -05003126 /* can_be_granted() detected that this lock would block in a conversion
3127 deadlock, so we leave it on the granted queue and return EDEADLK in
3128 the ast for the convert. */
3129
tsutomu.owa@toshiba.co.jp294e7e42017-09-15 14:17:23 -05003130 if (deadlk && !(lkb->lkb_exflags & DLM_LKF_NODLCKWT)) {
David Teiglandc85d65e2007-05-18 09:01:26 -05003131 /* it's left on the granted queue */
David Teiglandc85d65e2007-05-18 09:01:26 -05003132 revert_lock(r, lkb);
3133 queue_cast(r, lkb, -EDEADLK);
3134 error = -EDEADLK;
3135 goto out;
3136 }
3137
David Teigland7d3c1fe2007-04-19 10:30:41 -05003138 /* is_demoted() means the can_be_granted() above set the grmode
3139 to NL, and left us on the granted queue. This auto-demotion
3140 (due to CONVDEADLK) might mean other locks, and/or this lock, are
3141 now grantable. We have to try to grant other converting locks
3142 before we try again to grant this one. */
3143
3144 if (is_demoted(lkb)) {
David Teigland48756472012-04-26 15:54:29 -05003145 grant_pending_convert(r, DLM_LOCK_IV, NULL, NULL);
David Teiglandc503a622012-06-05 15:55:19 -05003146 if (_can_be_granted(r, lkb, 1, 0)) {
David Teigland7d3c1fe2007-04-19 10:30:41 -05003147 grant_lock(r, lkb);
3148 queue_cast(r, lkb, 0);
David Teigland7d3c1fe2007-04-19 10:30:41 -05003149 goto out;
3150 }
3151 /* else fall through and move to convert queue */
3152 }
3153
3154 if (can_be_queued(lkb)) {
David Teiglande7fd4172006-01-18 09:30:29 +00003155 error = -EINPROGRESS;
3156 del_lkb(r, lkb);
3157 add_lkb(r, lkb, DLM_LKSTS_CONVERT);
David Teigland3ae1acf2007-05-18 08:59:31 -05003158 add_timeout(lkb);
David Teiglande7fd4172006-01-18 09:30:29 +00003159 goto out;
3160 }
3161
3162 error = -EAGAIN;
David Teiglande7fd4172006-01-18 09:30:29 +00003163 queue_cast(r, lkb, -EAGAIN);
David Teiglande7fd4172006-01-18 09:30:29 +00003164 out:
3165 return error;
3166}
3167
David Teiglandcf6620a2010-02-24 11:59:23 -06003168static void do_convert_effects(struct dlm_rsb *r, struct dlm_lkb *lkb,
3169 int error)
3170{
3171 switch (error) {
3172 case 0:
David Teigland48756472012-04-26 15:54:29 -05003173 grant_pending_locks(r, NULL);
David Teiglandcf6620a2010-02-24 11:59:23 -06003174 /* grant_pending_locks also sends basts */
3175 break;
3176 case -EAGAIN:
3177 if (force_blocking_asts(lkb))
3178 send_blocking_asts_all(r, lkb);
3179 break;
3180 case -EINPROGRESS:
3181 send_blocking_asts(r, lkb);
3182 break;
3183 }
3184}
3185
David Teiglande7fd4172006-01-18 09:30:29 +00003186static int do_unlock(struct dlm_rsb *r, struct dlm_lkb *lkb)
3187{
3188 remove_lock(r, lkb);
3189 queue_cast(r, lkb, -DLM_EUNLOCK);
David Teiglande7fd4172006-01-18 09:30:29 +00003190 return -DLM_EUNLOCK;
3191}
3192
David Teiglandcf6620a2010-02-24 11:59:23 -06003193static void do_unlock_effects(struct dlm_rsb *r, struct dlm_lkb *lkb,
3194 int error)
3195{
David Teigland48756472012-04-26 15:54:29 -05003196 grant_pending_locks(r, NULL);
David Teiglandcf6620a2010-02-24 11:59:23 -06003197}
3198
David Teiglandef0c2bb2007-03-28 09:56:46 -05003199/* returns: 0 did nothing, -DLM_ECANCEL canceled lock */
David Teiglandc04fecb2012-05-10 10:18:07 -05003200
David Teiglande7fd4172006-01-18 09:30:29 +00003201static int do_cancel(struct dlm_rsb *r, struct dlm_lkb *lkb)
3202{
David Teiglandef0c2bb2007-03-28 09:56:46 -05003203 int error;
3204
3205 error = revert_lock(r, lkb);
3206 if (error) {
3207 queue_cast(r, lkb, -DLM_ECANCEL);
David Teiglandef0c2bb2007-03-28 09:56:46 -05003208 return -DLM_ECANCEL;
3209 }
3210 return 0;
David Teiglande7fd4172006-01-18 09:30:29 +00003211}
3212
David Teiglandcf6620a2010-02-24 11:59:23 -06003213static void do_cancel_effects(struct dlm_rsb *r, struct dlm_lkb *lkb,
3214 int error)
3215{
3216 if (error)
David Teigland48756472012-04-26 15:54:29 -05003217 grant_pending_locks(r, NULL);
David Teiglandcf6620a2010-02-24 11:59:23 -06003218}
3219
David Teiglande7fd4172006-01-18 09:30:29 +00003220/*
3221 * Four stage 3 varieties:
3222 * _request_lock(), _convert_lock(), _unlock_lock(), _cancel_lock()
3223 */
3224
3225/* add a new lkb to a possibly new rsb, called by requesting process */
3226
3227static int _request_lock(struct dlm_rsb *r, struct dlm_lkb *lkb)
3228{
3229 int error;
3230
3231 /* set_master: sets lkb nodeid from r */
3232
3233 error = set_master(r, lkb);
3234 if (error < 0)
3235 goto out;
3236 if (error) {
3237 error = 0;
3238 goto out;
3239 }
3240
David Teiglandcf6620a2010-02-24 11:59:23 -06003241 if (is_remote(r)) {
David Teiglande7fd4172006-01-18 09:30:29 +00003242 /* receive_request() calls do_request() on remote node */
3243 error = send_request(r, lkb);
David Teiglandcf6620a2010-02-24 11:59:23 -06003244 } else {
David Teiglande7fd4172006-01-18 09:30:29 +00003245 error = do_request(r, lkb);
David Teiglandcf6620a2010-02-24 11:59:23 -06003246 /* for remote locks the request_reply is sent
3247 between do_request and do_request_effects */
3248 do_request_effects(r, lkb, error);
3249 }
David Teiglande7fd4172006-01-18 09:30:29 +00003250 out:
3251 return error;
3252}
3253
David Teigland3bcd3682006-02-23 09:56:38 +00003254/* change some property of an existing lkb, e.g. mode */
David Teiglande7fd4172006-01-18 09:30:29 +00003255
3256static int _convert_lock(struct dlm_rsb *r, struct dlm_lkb *lkb)
3257{
3258 int error;
3259
David Teiglandcf6620a2010-02-24 11:59:23 -06003260 if (is_remote(r)) {
David Teiglande7fd4172006-01-18 09:30:29 +00003261 /* receive_convert() calls do_convert() on remote node */
3262 error = send_convert(r, lkb);
David Teiglandcf6620a2010-02-24 11:59:23 -06003263 } else {
David Teiglande7fd4172006-01-18 09:30:29 +00003264 error = do_convert(r, lkb);
David Teiglandcf6620a2010-02-24 11:59:23 -06003265 /* for remote locks the convert_reply is sent
3266 between do_convert and do_convert_effects */
3267 do_convert_effects(r, lkb, error);
3268 }
David Teiglande7fd4172006-01-18 09:30:29 +00003269
3270 return error;
3271}
3272
3273/* remove an existing lkb from the granted queue */
3274
3275static int _unlock_lock(struct dlm_rsb *r, struct dlm_lkb *lkb)
3276{
3277 int error;
3278
David Teiglandcf6620a2010-02-24 11:59:23 -06003279 if (is_remote(r)) {
David Teiglande7fd4172006-01-18 09:30:29 +00003280 /* receive_unlock() calls do_unlock() on remote node */
3281 error = send_unlock(r, lkb);
David Teiglandcf6620a2010-02-24 11:59:23 -06003282 } else {
David Teiglande7fd4172006-01-18 09:30:29 +00003283 error = do_unlock(r, lkb);
David Teiglandcf6620a2010-02-24 11:59:23 -06003284 /* for remote locks the unlock_reply is sent
3285 between do_unlock and do_unlock_effects */
3286 do_unlock_effects(r, lkb, error);
3287 }
David Teiglande7fd4172006-01-18 09:30:29 +00003288
3289 return error;
3290}
3291
3292/* remove an existing lkb from the convert or wait queue */
3293
3294static int _cancel_lock(struct dlm_rsb *r, struct dlm_lkb *lkb)
3295{
3296 int error;
3297
David Teiglandcf6620a2010-02-24 11:59:23 -06003298 if (is_remote(r)) {
David Teiglande7fd4172006-01-18 09:30:29 +00003299 /* receive_cancel() calls do_cancel() on remote node */
3300 error = send_cancel(r, lkb);
David Teiglandcf6620a2010-02-24 11:59:23 -06003301 } else {
David Teiglande7fd4172006-01-18 09:30:29 +00003302 error = do_cancel(r, lkb);
David Teiglandcf6620a2010-02-24 11:59:23 -06003303 /* for remote locks the cancel_reply is sent
3304 between do_cancel and do_cancel_effects */
3305 do_cancel_effects(r, lkb, error);
3306 }
David Teiglande7fd4172006-01-18 09:30:29 +00003307
3308 return error;
3309}
3310
3311/*
3312 * Four stage 2 varieties:
3313 * request_lock(), convert_lock(), unlock_lock(), cancel_lock()
3314 */
3315
3316static int request_lock(struct dlm_ls *ls, struct dlm_lkb *lkb, char *name,
3317 int len, struct dlm_args *args)
3318{
3319 struct dlm_rsb *r;
3320 int error;
3321
3322 error = validate_lock_args(ls, lkb, args);
3323 if (error)
David Teiglandc04fecb2012-05-10 10:18:07 -05003324 return error;
David Teiglande7fd4172006-01-18 09:30:29 +00003325
David Teiglandc04fecb2012-05-10 10:18:07 -05003326 error = find_rsb(ls, name, len, 0, R_REQUEST, &r);
David Teiglande7fd4172006-01-18 09:30:29 +00003327 if (error)
David Teiglandc04fecb2012-05-10 10:18:07 -05003328 return error;
David Teiglande7fd4172006-01-18 09:30:29 +00003329
3330 lock_rsb(r);
3331
3332 attach_lkb(r, lkb);
3333 lkb->lkb_lksb->sb_lkid = lkb->lkb_id;
3334
3335 error = _request_lock(r, lkb);
3336
3337 unlock_rsb(r);
3338 put_rsb(r);
David Teiglande7fd4172006-01-18 09:30:29 +00003339 return error;
3340}
3341
3342static int convert_lock(struct dlm_ls *ls, struct dlm_lkb *lkb,
3343 struct dlm_args *args)
3344{
3345 struct dlm_rsb *r;
3346 int error;
3347
3348 r = lkb->lkb_resource;
3349
3350 hold_rsb(r);
3351 lock_rsb(r);
3352
3353 error = validate_lock_args(ls, lkb, args);
3354 if (error)
3355 goto out;
3356
3357 error = _convert_lock(r, lkb);
3358 out:
3359 unlock_rsb(r);
3360 put_rsb(r);
3361 return error;
3362}
3363
3364static int unlock_lock(struct dlm_ls *ls, struct dlm_lkb *lkb,
3365 struct dlm_args *args)
3366{
3367 struct dlm_rsb *r;
3368 int error;
3369
3370 r = lkb->lkb_resource;
3371
3372 hold_rsb(r);
3373 lock_rsb(r);
3374
3375 error = validate_unlock_args(lkb, args);
3376 if (error)
3377 goto out;
3378
3379 error = _unlock_lock(r, lkb);
3380 out:
3381 unlock_rsb(r);
3382 put_rsb(r);
3383 return error;
3384}
3385
3386static int cancel_lock(struct dlm_ls *ls, struct dlm_lkb *lkb,
3387 struct dlm_args *args)
3388{
3389 struct dlm_rsb *r;
3390 int error;
3391
3392 r = lkb->lkb_resource;
3393
3394 hold_rsb(r);
3395 lock_rsb(r);
3396
3397 error = validate_unlock_args(lkb, args);
3398 if (error)
3399 goto out;
3400
3401 error = _cancel_lock(r, lkb);
3402 out:
3403 unlock_rsb(r);
3404 put_rsb(r);
3405 return error;
3406}
3407
3408/*
3409 * Two stage 1 varieties: dlm_lock() and dlm_unlock()
3410 */
3411
3412int dlm_lock(dlm_lockspace_t *lockspace,
3413 int mode,
3414 struct dlm_lksb *lksb,
3415 uint32_t flags,
3416 void *name,
3417 unsigned int namelen,
3418 uint32_t parent_lkid,
3419 void (*ast) (void *astarg),
3420 void *astarg,
David Teigland3bcd3682006-02-23 09:56:38 +00003421 void (*bast) (void *astarg, int mode))
David Teiglande7fd4172006-01-18 09:30:29 +00003422{
3423 struct dlm_ls *ls;
3424 struct dlm_lkb *lkb;
3425 struct dlm_args args;
3426 int error, convert = flags & DLM_LKF_CONVERT;
3427
3428 ls = dlm_find_lockspace_local(lockspace);
3429 if (!ls)
3430 return -EINVAL;
3431
David Teigland85e86ed2007-05-18 08:58:15 -05003432 dlm_lock_recovery(ls);
David Teiglande7fd4172006-01-18 09:30:29 +00003433
3434 if (convert)
3435 error = find_lkb(ls, lksb->sb_lkid, &lkb);
3436 else
3437 error = create_lkb(ls, &lkb);
3438
3439 if (error)
3440 goto out;
3441
David Teiglandd7db9232007-05-18 09:00:32 -05003442 error = set_lock_args(mode, lksb, flags, namelen, 0, ast,
David Teigland3bcd3682006-02-23 09:56:38 +00003443 astarg, bast, &args);
David Teiglande7fd4172006-01-18 09:30:29 +00003444 if (error)
3445 goto out_put;
3446
3447 if (convert)
3448 error = convert_lock(ls, lkb, &args);
3449 else
3450 error = request_lock(ls, lkb, name, namelen, &args);
3451
3452 if (error == -EINPROGRESS)
3453 error = 0;
3454 out_put:
3455 if (convert || error)
David Teiglandb3f58d82006-02-28 11:16:37 -05003456 __put_lkb(ls, lkb);
David Teiglandc85d65e2007-05-18 09:01:26 -05003457 if (error == -EAGAIN || error == -EDEADLK)
David Teiglande7fd4172006-01-18 09:30:29 +00003458 error = 0;
3459 out:
David Teigland85e86ed2007-05-18 08:58:15 -05003460 dlm_unlock_recovery(ls);
David Teiglande7fd4172006-01-18 09:30:29 +00003461 dlm_put_lockspace(ls);
3462 return error;
3463}
3464
3465int dlm_unlock(dlm_lockspace_t *lockspace,
3466 uint32_t lkid,
3467 uint32_t flags,
3468 struct dlm_lksb *lksb,
3469 void *astarg)
3470{
3471 struct dlm_ls *ls;
3472 struct dlm_lkb *lkb;
3473 struct dlm_args args;
3474 int error;
3475
3476 ls = dlm_find_lockspace_local(lockspace);
3477 if (!ls)
3478 return -EINVAL;
3479
David Teigland85e86ed2007-05-18 08:58:15 -05003480 dlm_lock_recovery(ls);
David Teiglande7fd4172006-01-18 09:30:29 +00003481
3482 error = find_lkb(ls, lkid, &lkb);
3483 if (error)
3484 goto out;
3485
3486 error = set_unlock_args(flags, astarg, &args);
3487 if (error)
3488 goto out_put;
3489
3490 if (flags & DLM_LKF_CANCEL)
3491 error = cancel_lock(ls, lkb, &args);
3492 else
3493 error = unlock_lock(ls, lkb, &args);
3494
3495 if (error == -DLM_EUNLOCK || error == -DLM_ECANCEL)
3496 error = 0;
David Teiglandef0c2bb2007-03-28 09:56:46 -05003497 if (error == -EBUSY && (flags & (DLM_LKF_CANCEL | DLM_LKF_FORCEUNLOCK)))
3498 error = 0;
David Teiglande7fd4172006-01-18 09:30:29 +00003499 out_put:
David Teiglandb3f58d82006-02-28 11:16:37 -05003500 dlm_put_lkb(lkb);
David Teiglande7fd4172006-01-18 09:30:29 +00003501 out:
David Teigland85e86ed2007-05-18 08:58:15 -05003502 dlm_unlock_recovery(ls);
David Teiglande7fd4172006-01-18 09:30:29 +00003503 dlm_put_lockspace(ls);
3504 return error;
3505}
3506
3507/*
3508 * send/receive routines for remote operations and replies
3509 *
3510 * send_args
3511 * send_common
3512 * send_request receive_request
3513 * send_convert receive_convert
3514 * send_unlock receive_unlock
3515 * send_cancel receive_cancel
3516 * send_grant receive_grant
3517 * send_bast receive_bast
3518 * send_lookup receive_lookup
3519 * send_remove receive_remove
3520 *
3521 * send_common_reply
3522 * receive_request_reply send_request_reply
3523 * receive_convert_reply send_convert_reply
3524 * receive_unlock_reply send_unlock_reply
3525 * receive_cancel_reply send_cancel_reply
3526 * receive_lookup_reply send_lookup_reply
3527 */
3528
David Teigland7e4dac32007-04-02 09:06:41 -05003529static int _create_message(struct dlm_ls *ls, int mb_len,
3530 int to_nodeid, int mstype,
3531 struct dlm_message **ms_ret,
3532 struct dlm_mhandle **mh_ret)
3533{
3534 struct dlm_message *ms;
3535 struct dlm_mhandle *mh;
3536 char *mb;
3537
3538 /* get_buffer gives us a message handle (mh) that we need to
3539 pass into lowcomms_commit and a message buffer (mb) that we
3540 write our data into */
3541
David Teigland573c24c2009-11-30 16:34:43 -06003542 mh = dlm_lowcomms_get_buffer(to_nodeid, mb_len, GFP_NOFS, &mb);
David Teigland7e4dac32007-04-02 09:06:41 -05003543 if (!mh)
3544 return -ENOBUFS;
3545
3546 memset(mb, 0, mb_len);
3547
3548 ms = (struct dlm_message *) mb;
3549
3550 ms->m_header.h_version = (DLM_HEADER_MAJOR | DLM_HEADER_MINOR);
3551 ms->m_header.h_lockspace = ls->ls_global_id;
3552 ms->m_header.h_nodeid = dlm_our_nodeid();
3553 ms->m_header.h_length = mb_len;
3554 ms->m_header.h_cmd = DLM_MSG;
3555
3556 ms->m_type = mstype;
3557
3558 *mh_ret = mh;
3559 *ms_ret = ms;
3560 return 0;
3561}
3562
David Teiglande7fd4172006-01-18 09:30:29 +00003563static int create_message(struct dlm_rsb *r, struct dlm_lkb *lkb,
3564 int to_nodeid, int mstype,
3565 struct dlm_message **ms_ret,
3566 struct dlm_mhandle **mh_ret)
3567{
David Teiglande7fd4172006-01-18 09:30:29 +00003568 int mb_len = sizeof(struct dlm_message);
3569
3570 switch (mstype) {
3571 case DLM_MSG_REQUEST:
3572 case DLM_MSG_LOOKUP:
3573 case DLM_MSG_REMOVE:
3574 mb_len += r->res_length;
3575 break;
3576 case DLM_MSG_CONVERT:
3577 case DLM_MSG_UNLOCK:
3578 case DLM_MSG_REQUEST_REPLY:
3579 case DLM_MSG_CONVERT_REPLY:
3580 case DLM_MSG_GRANT:
3581 if (lkb && lkb->lkb_lvbptr)
3582 mb_len += r->res_ls->ls_lvblen;
3583 break;
3584 }
3585
David Teigland7e4dac32007-04-02 09:06:41 -05003586 return _create_message(r->res_ls, mb_len, to_nodeid, mstype,
3587 ms_ret, mh_ret);
David Teiglande7fd4172006-01-18 09:30:29 +00003588}
3589
3590/* further lowcomms enhancements or alternate implementations may make
3591 the return value from this function useful at some point */
3592
3593static int send_message(struct dlm_mhandle *mh, struct dlm_message *ms)
3594{
3595 dlm_message_out(ms);
3596 dlm_lowcomms_commit_buffer(mh);
3597 return 0;
3598}
3599
3600static void send_args(struct dlm_rsb *r, struct dlm_lkb *lkb,
3601 struct dlm_message *ms)
3602{
3603 ms->m_nodeid = lkb->lkb_nodeid;
3604 ms->m_pid = lkb->lkb_ownpid;
3605 ms->m_lkid = lkb->lkb_id;
3606 ms->m_remid = lkb->lkb_remid;
3607 ms->m_exflags = lkb->lkb_exflags;
3608 ms->m_sbflags = lkb->lkb_sbflags;
3609 ms->m_flags = lkb->lkb_flags;
3610 ms->m_lvbseq = lkb->lkb_lvbseq;
3611 ms->m_status = lkb->lkb_status;
3612 ms->m_grmode = lkb->lkb_grmode;
3613 ms->m_rqmode = lkb->lkb_rqmode;
3614 ms->m_hash = r->res_hash;
3615
3616 /* m_result and m_bastmode are set from function args,
3617 not from lkb fields */
3618
David Teiglande5dae542008-02-06 00:35:45 -06003619 if (lkb->lkb_bastfn)
David Teigland8304d6f2011-02-21 14:58:21 -06003620 ms->m_asts |= DLM_CB_BAST;
David Teiglande5dae542008-02-06 00:35:45 -06003621 if (lkb->lkb_astfn)
David Teigland8304d6f2011-02-21 14:58:21 -06003622 ms->m_asts |= DLM_CB_CAST;
David Teiglande7fd4172006-01-18 09:30:29 +00003623
David Teiglandda49f362006-12-13 10:38:45 -06003624 /* compare with switch in create_message; send_remove() doesn't
3625 use send_args() */
3626
3627 switch (ms->m_type) {
3628 case DLM_MSG_REQUEST:
3629 case DLM_MSG_LOOKUP:
David Teiglande7fd4172006-01-18 09:30:29 +00003630 memcpy(ms->m_extra, r->res_name, r->res_length);
David Teiglandda49f362006-12-13 10:38:45 -06003631 break;
3632 case DLM_MSG_CONVERT:
3633 case DLM_MSG_UNLOCK:
3634 case DLM_MSG_REQUEST_REPLY:
3635 case DLM_MSG_CONVERT_REPLY:
3636 case DLM_MSG_GRANT:
3637 if (!lkb->lkb_lvbptr)
3638 break;
David Teiglande7fd4172006-01-18 09:30:29 +00003639 memcpy(ms->m_extra, lkb->lkb_lvbptr, r->res_ls->ls_lvblen);
David Teiglandda49f362006-12-13 10:38:45 -06003640 break;
3641 }
David Teiglande7fd4172006-01-18 09:30:29 +00003642}
3643
3644static int send_common(struct dlm_rsb *r, struct dlm_lkb *lkb, int mstype)
3645{
3646 struct dlm_message *ms;
3647 struct dlm_mhandle *mh;
3648 int to_nodeid, error;
3649
David Teiglandc6ff6692011-03-28 14:17:26 -05003650 to_nodeid = r->res_nodeid;
3651
3652 error = add_to_waiters(lkb, mstype, to_nodeid);
David Teiglandef0c2bb2007-03-28 09:56:46 -05003653 if (error)
3654 return error;
David Teiglande7fd4172006-01-18 09:30:29 +00003655
David Teiglande7fd4172006-01-18 09:30:29 +00003656 error = create_message(r, lkb, to_nodeid, mstype, &ms, &mh);
3657 if (error)
3658 goto fail;
3659
3660 send_args(r, lkb, ms);
3661
3662 error = send_message(mh, ms);
3663 if (error)
3664 goto fail;
3665 return 0;
3666
3667 fail:
David Teiglandef0c2bb2007-03-28 09:56:46 -05003668 remove_from_waiters(lkb, msg_reply_type(mstype));
David Teiglande7fd4172006-01-18 09:30:29 +00003669 return error;
3670}
3671
3672static int send_request(struct dlm_rsb *r, struct dlm_lkb *lkb)
3673{
3674 return send_common(r, lkb, DLM_MSG_REQUEST);
3675}
3676
3677static int send_convert(struct dlm_rsb *r, struct dlm_lkb *lkb)
3678{
3679 int error;
3680
3681 error = send_common(r, lkb, DLM_MSG_CONVERT);
3682
3683 /* down conversions go without a reply from the master */
3684 if (!error && down_conversion(lkb)) {
David Teiglandef0c2bb2007-03-28 09:56:46 -05003685 remove_from_waiters(lkb, DLM_MSG_CONVERT_REPLY);
David Teigland2a7ce0e2011-04-04 15:19:59 -05003686 r->res_ls->ls_stub_ms.m_flags = DLM_IFL_STUB_MS;
David Teiglandef0c2bb2007-03-28 09:56:46 -05003687 r->res_ls->ls_stub_ms.m_type = DLM_MSG_CONVERT_REPLY;
David Teiglande7fd4172006-01-18 09:30:29 +00003688 r->res_ls->ls_stub_ms.m_result = 0;
3689 __receive_convert_reply(r, lkb, &r->res_ls->ls_stub_ms);
3690 }
3691
3692 return error;
3693}
3694
3695/* FIXME: if this lkb is the only lock we hold on the rsb, then set
3696 MASTER_UNCERTAIN to force the next request on the rsb to confirm
3697 that the master is still correct. */
3698
3699static int send_unlock(struct dlm_rsb *r, struct dlm_lkb *lkb)
3700{
3701 return send_common(r, lkb, DLM_MSG_UNLOCK);
3702}
3703
3704static int send_cancel(struct dlm_rsb *r, struct dlm_lkb *lkb)
3705{
3706 return send_common(r, lkb, DLM_MSG_CANCEL);
3707}
3708
3709static int send_grant(struct dlm_rsb *r, struct dlm_lkb *lkb)
3710{
3711 struct dlm_message *ms;
3712 struct dlm_mhandle *mh;
3713 int to_nodeid, error;
3714
3715 to_nodeid = lkb->lkb_nodeid;
3716
3717 error = create_message(r, lkb, to_nodeid, DLM_MSG_GRANT, &ms, &mh);
3718 if (error)
3719 goto out;
3720
3721 send_args(r, lkb, ms);
3722
3723 ms->m_result = 0;
3724
3725 error = send_message(mh, ms);
3726 out:
3727 return error;
3728}
3729
3730static int send_bast(struct dlm_rsb *r, struct dlm_lkb *lkb, int mode)
3731{
3732 struct dlm_message *ms;
3733 struct dlm_mhandle *mh;
3734 int to_nodeid, error;
3735
3736 to_nodeid = lkb->lkb_nodeid;
3737
3738 error = create_message(r, NULL, to_nodeid, DLM_MSG_BAST, &ms, &mh);
3739 if (error)
3740 goto out;
3741
3742 send_args(r, lkb, ms);
3743
3744 ms->m_bastmode = mode;
3745
3746 error = send_message(mh, ms);
3747 out:
3748 return error;
3749}
3750
3751static int send_lookup(struct dlm_rsb *r, struct dlm_lkb *lkb)
3752{
3753 struct dlm_message *ms;
3754 struct dlm_mhandle *mh;
3755 int to_nodeid, error;
3756
David Teiglandc6ff6692011-03-28 14:17:26 -05003757 to_nodeid = dlm_dir_nodeid(r);
3758
3759 error = add_to_waiters(lkb, DLM_MSG_LOOKUP, to_nodeid);
David Teiglandef0c2bb2007-03-28 09:56:46 -05003760 if (error)
3761 return error;
David Teiglande7fd4172006-01-18 09:30:29 +00003762
David Teiglande7fd4172006-01-18 09:30:29 +00003763 error = create_message(r, NULL, to_nodeid, DLM_MSG_LOOKUP, &ms, &mh);
3764 if (error)
3765 goto fail;
3766
3767 send_args(r, lkb, ms);
3768
3769 error = send_message(mh, ms);
3770 if (error)
3771 goto fail;
3772 return 0;
3773
3774 fail:
David Teiglandef0c2bb2007-03-28 09:56:46 -05003775 remove_from_waiters(lkb, DLM_MSG_LOOKUP_REPLY);
David Teiglande7fd4172006-01-18 09:30:29 +00003776 return error;
3777}
3778
3779static int send_remove(struct dlm_rsb *r)
3780{
3781 struct dlm_message *ms;
3782 struct dlm_mhandle *mh;
3783 int to_nodeid, error;
3784
3785 to_nodeid = dlm_dir_nodeid(r);
3786
3787 error = create_message(r, NULL, to_nodeid, DLM_MSG_REMOVE, &ms, &mh);
3788 if (error)
3789 goto out;
3790
3791 memcpy(ms->m_extra, r->res_name, r->res_length);
3792 ms->m_hash = r->res_hash;
3793
3794 error = send_message(mh, ms);
3795 out:
3796 return error;
3797}
3798
3799static int send_common_reply(struct dlm_rsb *r, struct dlm_lkb *lkb,
3800 int mstype, int rv)
3801{
3802 struct dlm_message *ms;
3803 struct dlm_mhandle *mh;
3804 int to_nodeid, error;
3805
3806 to_nodeid = lkb->lkb_nodeid;
3807
3808 error = create_message(r, lkb, to_nodeid, mstype, &ms, &mh);
3809 if (error)
3810 goto out;
3811
3812 send_args(r, lkb, ms);
3813
3814 ms->m_result = rv;
3815
3816 error = send_message(mh, ms);
3817 out:
3818 return error;
3819}
3820
3821static int send_request_reply(struct dlm_rsb *r, struct dlm_lkb *lkb, int rv)
3822{
3823 return send_common_reply(r, lkb, DLM_MSG_REQUEST_REPLY, rv);
3824}
3825
3826static int send_convert_reply(struct dlm_rsb *r, struct dlm_lkb *lkb, int rv)
3827{
3828 return send_common_reply(r, lkb, DLM_MSG_CONVERT_REPLY, rv);
3829}
3830
3831static int send_unlock_reply(struct dlm_rsb *r, struct dlm_lkb *lkb, int rv)
3832{
3833 return send_common_reply(r, lkb, DLM_MSG_UNLOCK_REPLY, rv);
3834}
3835
3836static int send_cancel_reply(struct dlm_rsb *r, struct dlm_lkb *lkb, int rv)
3837{
3838 return send_common_reply(r, lkb, DLM_MSG_CANCEL_REPLY, rv);
3839}
3840
3841static int send_lookup_reply(struct dlm_ls *ls, struct dlm_message *ms_in,
3842 int ret_nodeid, int rv)
3843{
3844 struct dlm_rsb *r = &ls->ls_stub_rsb;
3845 struct dlm_message *ms;
3846 struct dlm_mhandle *mh;
3847 int error, nodeid = ms_in->m_header.h_nodeid;
3848
3849 error = create_message(r, NULL, nodeid, DLM_MSG_LOOKUP_REPLY, &ms, &mh);
3850 if (error)
3851 goto out;
3852
3853 ms->m_lkid = ms_in->m_lkid;
3854 ms->m_result = rv;
3855 ms->m_nodeid = ret_nodeid;
3856
3857 error = send_message(mh, ms);
3858 out:
3859 return error;
3860}
3861
3862/* which args we save from a received message depends heavily on the type
3863 of message, unlike the send side where we can safely send everything about
3864 the lkb for any type of message */
3865
3866static void receive_flags(struct dlm_lkb *lkb, struct dlm_message *ms)
3867{
3868 lkb->lkb_exflags = ms->m_exflags;
David Teigland6f90a8b12006-11-10 14:16:27 -06003869 lkb->lkb_sbflags = ms->m_sbflags;
David Teiglande7fd4172006-01-18 09:30:29 +00003870 lkb->lkb_flags = (lkb->lkb_flags & 0xFFFF0000) |
3871 (ms->m_flags & 0x0000FFFF);
3872}
3873
3874static void receive_flags_reply(struct dlm_lkb *lkb, struct dlm_message *ms)
3875{
David Teigland2a7ce0e2011-04-04 15:19:59 -05003876 if (ms->m_flags == DLM_IFL_STUB_MS)
3877 return;
3878
David Teiglande7fd4172006-01-18 09:30:29 +00003879 lkb->lkb_sbflags = ms->m_sbflags;
3880 lkb->lkb_flags = (lkb->lkb_flags & 0xFFFF0000) |
3881 (ms->m_flags & 0x0000FFFF);
3882}
3883
3884static int receive_extralen(struct dlm_message *ms)
3885{
3886 return (ms->m_header.h_length - sizeof(struct dlm_message));
3887}
3888
David Teiglande7fd4172006-01-18 09:30:29 +00003889static int receive_lvb(struct dlm_ls *ls, struct dlm_lkb *lkb,
3890 struct dlm_message *ms)
3891{
3892 int len;
3893
3894 if (lkb->lkb_exflags & DLM_LKF_VALBLK) {
3895 if (!lkb->lkb_lvbptr)
David Teigland52bda2b2007-11-07 09:06:49 -06003896 lkb->lkb_lvbptr = dlm_allocate_lvb(ls);
David Teiglande7fd4172006-01-18 09:30:29 +00003897 if (!lkb->lkb_lvbptr)
3898 return -ENOMEM;
3899 len = receive_extralen(ms);
Bart Van Asschecfa805f2013-06-26 14:27:57 +02003900 if (len > ls->ls_lvblen)
3901 len = ls->ls_lvblen;
David Teiglande7fd4172006-01-18 09:30:29 +00003902 memcpy(lkb->lkb_lvbptr, ms->m_extra, len);
3903 }
3904 return 0;
3905}
3906
David Teiglande5dae542008-02-06 00:35:45 -06003907static void fake_bastfn(void *astparam, int mode)
3908{
3909 log_print("fake_bastfn should not be called");
3910}
3911
3912static void fake_astfn(void *astparam)
3913{
3914 log_print("fake_astfn should not be called");
3915}
3916
David Teiglande7fd4172006-01-18 09:30:29 +00003917static int receive_request_args(struct dlm_ls *ls, struct dlm_lkb *lkb,
3918 struct dlm_message *ms)
3919{
3920 lkb->lkb_nodeid = ms->m_header.h_nodeid;
3921 lkb->lkb_ownpid = ms->m_pid;
3922 lkb->lkb_remid = ms->m_lkid;
3923 lkb->lkb_grmode = DLM_LOCK_IV;
3924 lkb->lkb_rqmode = ms->m_rqmode;
David Teiglande5dae542008-02-06 00:35:45 -06003925
David Teigland8304d6f2011-02-21 14:58:21 -06003926 lkb->lkb_bastfn = (ms->m_asts & DLM_CB_BAST) ? &fake_bastfn : NULL;
3927 lkb->lkb_astfn = (ms->m_asts & DLM_CB_CAST) ? &fake_astfn : NULL;
David Teiglande7fd4172006-01-18 09:30:29 +00003928
David Teigland8d07fd52006-12-13 10:39:20 -06003929 if (lkb->lkb_exflags & DLM_LKF_VALBLK) {
3930 /* lkb was just created so there won't be an lvb yet */
David Teigland52bda2b2007-11-07 09:06:49 -06003931 lkb->lkb_lvbptr = dlm_allocate_lvb(ls);
David Teigland8d07fd52006-12-13 10:39:20 -06003932 if (!lkb->lkb_lvbptr)
3933 return -ENOMEM;
3934 }
David Teiglande7fd4172006-01-18 09:30:29 +00003935
3936 return 0;
3937}
3938
3939static int receive_convert_args(struct dlm_ls *ls, struct dlm_lkb *lkb,
3940 struct dlm_message *ms)
3941{
David Teiglande7fd4172006-01-18 09:30:29 +00003942 if (lkb->lkb_status != DLM_LKSTS_GRANTED)
3943 return -EBUSY;
3944
David Teiglande7fd4172006-01-18 09:30:29 +00003945 if (receive_lvb(ls, lkb, ms))
3946 return -ENOMEM;
3947
3948 lkb->lkb_rqmode = ms->m_rqmode;
3949 lkb->lkb_lvbseq = ms->m_lvbseq;
3950
3951 return 0;
3952}
3953
3954static int receive_unlock_args(struct dlm_ls *ls, struct dlm_lkb *lkb,
3955 struct dlm_message *ms)
3956{
David Teiglande7fd4172006-01-18 09:30:29 +00003957 if (receive_lvb(ls, lkb, ms))
3958 return -ENOMEM;
3959 return 0;
3960}
3961
3962/* We fill in the stub-lkb fields with the info that send_xxxx_reply()
3963 uses to send a reply and that the remote end uses to process the reply. */
3964
3965static void setup_stub_lkb(struct dlm_ls *ls, struct dlm_message *ms)
3966{
3967 struct dlm_lkb *lkb = &ls->ls_stub_lkb;
3968 lkb->lkb_nodeid = ms->m_header.h_nodeid;
3969 lkb->lkb_remid = ms->m_lkid;
3970}
3971
David Teiglandc54e04b2008-01-09 09:59:41 -06003972/* This is called after the rsb is locked so that we can safely inspect
3973 fields in the lkb. */
3974
3975static int validate_message(struct dlm_lkb *lkb, struct dlm_message *ms)
3976{
3977 int from = ms->m_header.h_nodeid;
3978 int error = 0;
3979
3980 switch (ms->m_type) {
3981 case DLM_MSG_CONVERT:
3982 case DLM_MSG_UNLOCK:
3983 case DLM_MSG_CANCEL:
3984 if (!is_master_copy(lkb) || lkb->lkb_nodeid != from)
3985 error = -EINVAL;
3986 break;
3987
3988 case DLM_MSG_CONVERT_REPLY:
3989 case DLM_MSG_UNLOCK_REPLY:
3990 case DLM_MSG_CANCEL_REPLY:
3991 case DLM_MSG_GRANT:
3992 case DLM_MSG_BAST:
3993 if (!is_process_copy(lkb) || lkb->lkb_nodeid != from)
3994 error = -EINVAL;
3995 break;
3996
3997 case DLM_MSG_REQUEST_REPLY:
3998 if (!is_process_copy(lkb))
3999 error = -EINVAL;
4000 else if (lkb->lkb_nodeid != -1 && lkb->lkb_nodeid != from)
4001 error = -EINVAL;
4002 break;
4003
4004 default:
4005 error = -EINVAL;
4006 }
4007
4008 if (error)
4009 log_error(lkb->lkb_resource->res_ls,
4010 "ignore invalid message %d from %d %x %x %x %d",
4011 ms->m_type, from, lkb->lkb_id, lkb->lkb_remid,
4012 lkb->lkb_flags, lkb->lkb_nodeid);
4013 return error;
4014}
4015
David Teigland96006ea2012-06-25 13:48:05 -05004016static void send_repeat_remove(struct dlm_ls *ls, char *ms_name, int len)
4017{
4018 char name[DLM_RESNAME_MAXLEN + 1];
4019 struct dlm_message *ms;
4020 struct dlm_mhandle *mh;
4021 struct dlm_rsb *r;
4022 uint32_t hash, b;
4023 int rv, dir_nodeid;
4024
4025 memset(name, 0, sizeof(name));
4026 memcpy(name, ms_name, len);
4027
4028 hash = jhash(name, len, 0);
4029 b = hash & (ls->ls_rsbtbl_size - 1);
4030
4031 dir_nodeid = dlm_hash2nodeid(ls, hash);
4032
4033 log_error(ls, "send_repeat_remove dir %d %s", dir_nodeid, name);
4034
4035 spin_lock(&ls->ls_rsbtbl[b].lock);
4036 rv = dlm_search_rsb_tree(&ls->ls_rsbtbl[b].keep, name, len, &r);
4037 if (!rv) {
4038 spin_unlock(&ls->ls_rsbtbl[b].lock);
4039 log_error(ls, "repeat_remove on keep %s", name);
4040 return;
4041 }
4042
4043 rv = dlm_search_rsb_tree(&ls->ls_rsbtbl[b].toss, name, len, &r);
4044 if (!rv) {
4045 spin_unlock(&ls->ls_rsbtbl[b].lock);
4046 log_error(ls, "repeat_remove on toss %s", name);
4047 return;
4048 }
4049
4050 /* use ls->remove_name2 to avoid conflict with shrink? */
4051
4052 spin_lock(&ls->ls_remove_spin);
4053 ls->ls_remove_len = len;
4054 memcpy(ls->ls_remove_name, name, DLM_RESNAME_MAXLEN);
4055 spin_unlock(&ls->ls_remove_spin);
4056 spin_unlock(&ls->ls_rsbtbl[b].lock);
4057
4058 rv = _create_message(ls, sizeof(struct dlm_message) + len,
4059 dir_nodeid, DLM_MSG_REMOVE, &ms, &mh);
4060 if (rv)
4061 return;
4062
4063 memcpy(ms->m_extra, name, len);
4064 ms->m_hash = hash;
4065
4066 send_message(mh, ms);
4067
4068 spin_lock(&ls->ls_remove_spin);
4069 ls->ls_remove_len = 0;
4070 memset(ls->ls_remove_name, 0, DLM_RESNAME_MAXLEN);
4071 spin_unlock(&ls->ls_remove_spin);
4072}
4073
David Teigland6d40c4a2012-04-23 16:36:01 -05004074static int receive_request(struct dlm_ls *ls, struct dlm_message *ms)
David Teiglande7fd4172006-01-18 09:30:29 +00004075{
4076 struct dlm_lkb *lkb;
4077 struct dlm_rsb *r;
David Teiglandc04fecb2012-05-10 10:18:07 -05004078 int from_nodeid;
David Teigland96006ea2012-06-25 13:48:05 -05004079 int error, namelen = 0;
David Teiglande7fd4172006-01-18 09:30:29 +00004080
David Teiglandc04fecb2012-05-10 10:18:07 -05004081 from_nodeid = ms->m_header.h_nodeid;
4082
David Teiglande7fd4172006-01-18 09:30:29 +00004083 error = create_lkb(ls, &lkb);
4084 if (error)
4085 goto fail;
4086
4087 receive_flags(lkb, ms);
4088 lkb->lkb_flags |= DLM_IFL_MSTCPY;
4089 error = receive_request_args(ls, lkb, ms);
4090 if (error) {
David Teiglandb3f58d82006-02-28 11:16:37 -05004091 __put_lkb(ls, lkb);
David Teiglande7fd4172006-01-18 09:30:29 +00004092 goto fail;
4093 }
4094
David Teiglandc04fecb2012-05-10 10:18:07 -05004095 /* The dir node is the authority on whether we are the master
4096 for this rsb or not, so if the master sends us a request, we should
4097 recreate the rsb if we've destroyed it. This race happens when we
4098 send a remove message to the dir node at the same time that the dir
4099 node sends us a request for the rsb. */
4100
David Teiglande7fd4172006-01-18 09:30:29 +00004101 namelen = receive_extralen(ms);
4102
David Teiglandc04fecb2012-05-10 10:18:07 -05004103 error = find_rsb(ls, ms->m_extra, namelen, from_nodeid,
4104 R_RECEIVE_REQUEST, &r);
David Teiglande7fd4172006-01-18 09:30:29 +00004105 if (error) {
David Teiglandb3f58d82006-02-28 11:16:37 -05004106 __put_lkb(ls, lkb);
David Teiglande7fd4172006-01-18 09:30:29 +00004107 goto fail;
4108 }
4109
4110 lock_rsb(r);
4111
David Teiglandc04fecb2012-05-10 10:18:07 -05004112 if (r->res_master_nodeid != dlm_our_nodeid()) {
4113 error = validate_master_nodeid(ls, r, from_nodeid);
4114 if (error) {
4115 unlock_rsb(r);
4116 put_rsb(r);
4117 __put_lkb(ls, lkb);
4118 goto fail;
4119 }
4120 }
4121
David Teiglande7fd4172006-01-18 09:30:29 +00004122 attach_lkb(r, lkb);
4123 error = do_request(r, lkb);
4124 send_request_reply(r, lkb, error);
David Teiglandcf6620a2010-02-24 11:59:23 -06004125 do_request_effects(r, lkb, error);
David Teiglande7fd4172006-01-18 09:30:29 +00004126
4127 unlock_rsb(r);
4128 put_rsb(r);
4129
4130 if (error == -EINPROGRESS)
4131 error = 0;
4132 if (error)
David Teiglandb3f58d82006-02-28 11:16:37 -05004133 dlm_put_lkb(lkb);
David Teigland6d40c4a2012-04-23 16:36:01 -05004134 return 0;
David Teiglande7fd4172006-01-18 09:30:29 +00004135
4136 fail:
David Teiglandc04fecb2012-05-10 10:18:07 -05004137 /* TODO: instead of returning ENOTBLK, add the lkb to res_lookup
4138 and do this receive_request again from process_lookup_list once
4139 we get the lookup reply. This would avoid a many repeated
4140 ENOTBLK request failures when the lookup reply designating us
4141 as master is delayed. */
4142
4143 /* We could repeatedly return -EBADR here if our send_remove() is
4144 delayed in being sent/arriving/being processed on the dir node.
4145 Another node would repeatedly lookup up the master, and the dir
4146 node would continue returning our nodeid until our send_remove
David Teigland96006ea2012-06-25 13:48:05 -05004147 took effect.
4148
4149 We send another remove message in case our previous send_remove
4150 was lost/ignored/missed somehow. */
David Teiglandc04fecb2012-05-10 10:18:07 -05004151
4152 if (error != -ENOTBLK) {
4153 log_limit(ls, "receive_request %x from %d %d",
4154 ms->m_lkid, from_nodeid, error);
4155 }
4156
David Teigland96006ea2012-06-25 13:48:05 -05004157 if (namelen && error == -EBADR) {
4158 send_repeat_remove(ls, ms->m_extra, namelen);
4159 msleep(1000);
4160 }
4161
David Teiglande7fd4172006-01-18 09:30:29 +00004162 setup_stub_lkb(ls, ms);
4163 send_request_reply(&ls->ls_stub_rsb, &ls->ls_stub_lkb, error);
David Teigland6d40c4a2012-04-23 16:36:01 -05004164 return error;
David Teiglande7fd4172006-01-18 09:30:29 +00004165}
4166
David Teigland6d40c4a2012-04-23 16:36:01 -05004167static int receive_convert(struct dlm_ls *ls, struct dlm_message *ms)
David Teiglande7fd4172006-01-18 09:30:29 +00004168{
4169 struct dlm_lkb *lkb;
4170 struct dlm_rsb *r;
David Teigland90135922006-01-20 08:47:07 +00004171 int error, reply = 1;
David Teiglande7fd4172006-01-18 09:30:29 +00004172
4173 error = find_lkb(ls, ms->m_remid, &lkb);
4174 if (error)
4175 goto fail;
4176
David Teigland6d40c4a2012-04-23 16:36:01 -05004177 if (lkb->lkb_remid != ms->m_lkid) {
David Teigland48756472012-04-26 15:54:29 -05004178 log_error(ls, "receive_convert %x remid %x recover_seq %llu "
4179 "remote %d %x", lkb->lkb_id, lkb->lkb_remid,
4180 (unsigned long long)lkb->lkb_recover_seq,
David Teigland6d40c4a2012-04-23 16:36:01 -05004181 ms->m_header.h_nodeid, ms->m_lkid);
4182 error = -ENOENT;
Vasily Averinc0174722018-11-15 13:18:24 +03004183 dlm_put_lkb(lkb);
David Teigland6d40c4a2012-04-23 16:36:01 -05004184 goto fail;
4185 }
4186
David Teiglande7fd4172006-01-18 09:30:29 +00004187 r = lkb->lkb_resource;
4188
4189 hold_rsb(r);
4190 lock_rsb(r);
4191
David Teiglandc54e04b2008-01-09 09:59:41 -06004192 error = validate_message(lkb, ms);
4193 if (error)
4194 goto out;
4195
David Teiglande7fd4172006-01-18 09:30:29 +00004196 receive_flags(lkb, ms);
David Teiglandcf6620a2010-02-24 11:59:23 -06004197
David Teiglande7fd4172006-01-18 09:30:29 +00004198 error = receive_convert_args(ls, lkb, ms);
David Teiglandcf6620a2010-02-24 11:59:23 -06004199 if (error) {
4200 send_convert_reply(r, lkb, error);
4201 goto out;
4202 }
4203
David Teiglande7fd4172006-01-18 09:30:29 +00004204 reply = !down_conversion(lkb);
4205
4206 error = do_convert(r, lkb);
David Teiglande7fd4172006-01-18 09:30:29 +00004207 if (reply)
4208 send_convert_reply(r, lkb, error);
David Teiglandcf6620a2010-02-24 11:59:23 -06004209 do_convert_effects(r, lkb, error);
David Teiglandc54e04b2008-01-09 09:59:41 -06004210 out:
David Teiglande7fd4172006-01-18 09:30:29 +00004211 unlock_rsb(r);
4212 put_rsb(r);
David Teiglandb3f58d82006-02-28 11:16:37 -05004213 dlm_put_lkb(lkb);
David Teigland6d40c4a2012-04-23 16:36:01 -05004214 return 0;
David Teiglande7fd4172006-01-18 09:30:29 +00004215
4216 fail:
4217 setup_stub_lkb(ls, ms);
4218 send_convert_reply(&ls->ls_stub_rsb, &ls->ls_stub_lkb, error);
David Teigland6d40c4a2012-04-23 16:36:01 -05004219 return error;
David Teiglande7fd4172006-01-18 09:30:29 +00004220}
4221
David Teigland6d40c4a2012-04-23 16:36:01 -05004222static int receive_unlock(struct dlm_ls *ls, struct dlm_message *ms)
David Teiglande7fd4172006-01-18 09:30:29 +00004223{
4224 struct dlm_lkb *lkb;
4225 struct dlm_rsb *r;
4226 int error;
4227
4228 error = find_lkb(ls, ms->m_remid, &lkb);
4229 if (error)
4230 goto fail;
4231
David Teigland6d40c4a2012-04-23 16:36:01 -05004232 if (lkb->lkb_remid != ms->m_lkid) {
4233 log_error(ls, "receive_unlock %x remid %x remote %d %x",
4234 lkb->lkb_id, lkb->lkb_remid,
4235 ms->m_header.h_nodeid, ms->m_lkid);
4236 error = -ENOENT;
Vasily Averinc0174722018-11-15 13:18:24 +03004237 dlm_put_lkb(lkb);
David Teigland6d40c4a2012-04-23 16:36:01 -05004238 goto fail;
4239 }
4240
David Teiglande7fd4172006-01-18 09:30:29 +00004241 r = lkb->lkb_resource;
4242
4243 hold_rsb(r);
4244 lock_rsb(r);
4245
David Teiglandc54e04b2008-01-09 09:59:41 -06004246 error = validate_message(lkb, ms);
David Teiglande7fd4172006-01-18 09:30:29 +00004247 if (error)
4248 goto out;
4249
David Teiglandc54e04b2008-01-09 09:59:41 -06004250 receive_flags(lkb, ms);
David Teiglandcf6620a2010-02-24 11:59:23 -06004251
David Teiglandc54e04b2008-01-09 09:59:41 -06004252 error = receive_unlock_args(ls, lkb, ms);
David Teiglandcf6620a2010-02-24 11:59:23 -06004253 if (error) {
4254 send_unlock_reply(r, lkb, error);
4255 goto out;
4256 }
David Teiglande7fd4172006-01-18 09:30:29 +00004257
David Teiglandc54e04b2008-01-09 09:59:41 -06004258 error = do_unlock(r, lkb);
David Teiglandc54e04b2008-01-09 09:59:41 -06004259 send_unlock_reply(r, lkb, error);
David Teiglandcf6620a2010-02-24 11:59:23 -06004260 do_unlock_effects(r, lkb, error);
David Teiglandc54e04b2008-01-09 09:59:41 -06004261 out:
David Teiglande7fd4172006-01-18 09:30:29 +00004262 unlock_rsb(r);
4263 put_rsb(r);
David Teiglandb3f58d82006-02-28 11:16:37 -05004264 dlm_put_lkb(lkb);
David Teigland6d40c4a2012-04-23 16:36:01 -05004265 return 0;
David Teiglande7fd4172006-01-18 09:30:29 +00004266
4267 fail:
4268 setup_stub_lkb(ls, ms);
4269 send_unlock_reply(&ls->ls_stub_rsb, &ls->ls_stub_lkb, error);
David Teigland6d40c4a2012-04-23 16:36:01 -05004270 return error;
David Teiglande7fd4172006-01-18 09:30:29 +00004271}
4272
David Teigland6d40c4a2012-04-23 16:36:01 -05004273static int receive_cancel(struct dlm_ls *ls, struct dlm_message *ms)
David Teiglande7fd4172006-01-18 09:30:29 +00004274{
4275 struct dlm_lkb *lkb;
4276 struct dlm_rsb *r;
4277 int error;
4278
4279 error = find_lkb(ls, ms->m_remid, &lkb);
4280 if (error)
4281 goto fail;
4282
4283 receive_flags(lkb, ms);
4284
4285 r = lkb->lkb_resource;
4286
4287 hold_rsb(r);
4288 lock_rsb(r);
4289
David Teiglandc54e04b2008-01-09 09:59:41 -06004290 error = validate_message(lkb, ms);
4291 if (error)
4292 goto out;
4293
David Teiglande7fd4172006-01-18 09:30:29 +00004294 error = do_cancel(r, lkb);
4295 send_cancel_reply(r, lkb, error);
David Teiglandcf6620a2010-02-24 11:59:23 -06004296 do_cancel_effects(r, lkb, error);
David Teiglandc54e04b2008-01-09 09:59:41 -06004297 out:
David Teiglande7fd4172006-01-18 09:30:29 +00004298 unlock_rsb(r);
4299 put_rsb(r);
David Teiglandb3f58d82006-02-28 11:16:37 -05004300 dlm_put_lkb(lkb);
David Teigland6d40c4a2012-04-23 16:36:01 -05004301 return 0;
David Teiglande7fd4172006-01-18 09:30:29 +00004302
4303 fail:
4304 setup_stub_lkb(ls, ms);
4305 send_cancel_reply(&ls->ls_stub_rsb, &ls->ls_stub_lkb, error);
David Teigland6d40c4a2012-04-23 16:36:01 -05004306 return error;
David Teiglande7fd4172006-01-18 09:30:29 +00004307}
4308
David Teigland6d40c4a2012-04-23 16:36:01 -05004309static int receive_grant(struct dlm_ls *ls, struct dlm_message *ms)
David Teiglande7fd4172006-01-18 09:30:29 +00004310{
4311 struct dlm_lkb *lkb;
4312 struct dlm_rsb *r;
4313 int error;
4314
4315 error = find_lkb(ls, ms->m_remid, &lkb);
David Teigland6d40c4a2012-04-23 16:36:01 -05004316 if (error)
4317 return error;
David Teiglande7fd4172006-01-18 09:30:29 +00004318
4319 r = lkb->lkb_resource;
4320
4321 hold_rsb(r);
4322 lock_rsb(r);
4323
David Teiglandc54e04b2008-01-09 09:59:41 -06004324 error = validate_message(lkb, ms);
4325 if (error)
4326 goto out;
4327
David Teiglande7fd4172006-01-18 09:30:29 +00004328 receive_flags_reply(lkb, ms);
David Teigland7d3c1fe2007-04-19 10:30:41 -05004329 if (is_altmode(lkb))
4330 munge_altmode(lkb, ms);
David Teiglande7fd4172006-01-18 09:30:29 +00004331 grant_lock_pc(r, lkb, ms);
4332 queue_cast(r, lkb, 0);
David Teiglandc54e04b2008-01-09 09:59:41 -06004333 out:
David Teiglande7fd4172006-01-18 09:30:29 +00004334 unlock_rsb(r);
4335 put_rsb(r);
David Teiglandb3f58d82006-02-28 11:16:37 -05004336 dlm_put_lkb(lkb);
David Teigland6d40c4a2012-04-23 16:36:01 -05004337 return 0;
David Teiglande7fd4172006-01-18 09:30:29 +00004338}
4339
David Teigland6d40c4a2012-04-23 16:36:01 -05004340static int receive_bast(struct dlm_ls *ls, struct dlm_message *ms)
David Teiglande7fd4172006-01-18 09:30:29 +00004341{
4342 struct dlm_lkb *lkb;
4343 struct dlm_rsb *r;
4344 int error;
4345
4346 error = find_lkb(ls, ms->m_remid, &lkb);
David Teigland6d40c4a2012-04-23 16:36:01 -05004347 if (error)
4348 return error;
David Teiglande7fd4172006-01-18 09:30:29 +00004349
4350 r = lkb->lkb_resource;
4351
4352 hold_rsb(r);
4353 lock_rsb(r);
4354
David Teiglandc54e04b2008-01-09 09:59:41 -06004355 error = validate_message(lkb, ms);
4356 if (error)
4357 goto out;
David Teiglande7fd4172006-01-18 09:30:29 +00004358
David Teiglandc54e04b2008-01-09 09:59:41 -06004359 queue_bast(r, lkb, ms->m_bastmode);
David Teigland48756472012-04-26 15:54:29 -05004360 lkb->lkb_highbast = ms->m_bastmode;
David Teiglandc54e04b2008-01-09 09:59:41 -06004361 out:
David Teiglande7fd4172006-01-18 09:30:29 +00004362 unlock_rsb(r);
4363 put_rsb(r);
David Teiglandb3f58d82006-02-28 11:16:37 -05004364 dlm_put_lkb(lkb);
David Teigland6d40c4a2012-04-23 16:36:01 -05004365 return 0;
David Teiglande7fd4172006-01-18 09:30:29 +00004366}
4367
4368static void receive_lookup(struct dlm_ls *ls, struct dlm_message *ms)
4369{
David Teiglandc04fecb2012-05-10 10:18:07 -05004370 int len, error, ret_nodeid, from_nodeid, our_nodeid;
David Teiglande7fd4172006-01-18 09:30:29 +00004371
4372 from_nodeid = ms->m_header.h_nodeid;
4373 our_nodeid = dlm_our_nodeid();
4374
4375 len = receive_extralen(ms);
4376
David Teiglandc04fecb2012-05-10 10:18:07 -05004377 error = dlm_master_lookup(ls, from_nodeid, ms->m_extra, len, 0,
4378 &ret_nodeid, NULL);
David Teiglande7fd4172006-01-18 09:30:29 +00004379
4380 /* Optimization: we're master so treat lookup as a request */
4381 if (!error && ret_nodeid == our_nodeid) {
4382 receive_request(ls, ms);
4383 return;
4384 }
David Teiglande7fd4172006-01-18 09:30:29 +00004385 send_lookup_reply(ls, ms, ret_nodeid, error);
4386}
4387
4388static void receive_remove(struct dlm_ls *ls, struct dlm_message *ms)
4389{
David Teiglandc04fecb2012-05-10 10:18:07 -05004390 char name[DLM_RESNAME_MAXLEN+1];
4391 struct dlm_rsb *r;
4392 uint32_t hash, b;
4393 int rv, len, dir_nodeid, from_nodeid;
David Teiglande7fd4172006-01-18 09:30:29 +00004394
4395 from_nodeid = ms->m_header.h_nodeid;
4396
4397 len = receive_extralen(ms);
4398
David Teiglandc04fecb2012-05-10 10:18:07 -05004399 if (len > DLM_RESNAME_MAXLEN) {
4400 log_error(ls, "receive_remove from %d bad len %d",
4401 from_nodeid, len);
David Teiglande7fd4172006-01-18 09:30:29 +00004402 return;
4403 }
4404
David Teiglandc04fecb2012-05-10 10:18:07 -05004405 dir_nodeid = dlm_hash2nodeid(ls, ms->m_hash);
4406 if (dir_nodeid != dlm_our_nodeid()) {
4407 log_error(ls, "receive_remove from %d bad nodeid %d",
4408 from_nodeid, dir_nodeid);
4409 return;
4410 }
4411
4412 /* Look for name on rsbtbl.toss, if it's there, kill it.
4413 If it's on rsbtbl.keep, it's being used, and we should ignore this
4414 message. This is an expected race between the dir node sending a
4415 request to the master node at the same time as the master node sends
4416 a remove to the dir node. The resolution to that race is for the
4417 dir node to ignore the remove message, and the master node to
4418 recreate the master rsb when it gets a request from the dir node for
4419 an rsb it doesn't have. */
4420
4421 memset(name, 0, sizeof(name));
4422 memcpy(name, ms->m_extra, len);
4423
4424 hash = jhash(name, len, 0);
4425 b = hash & (ls->ls_rsbtbl_size - 1);
4426
4427 spin_lock(&ls->ls_rsbtbl[b].lock);
4428
4429 rv = dlm_search_rsb_tree(&ls->ls_rsbtbl[b].toss, name, len, &r);
4430 if (rv) {
4431 /* verify the rsb is on keep list per comment above */
4432 rv = dlm_search_rsb_tree(&ls->ls_rsbtbl[b].keep, name, len, &r);
4433 if (rv) {
4434 /* should not happen */
4435 log_error(ls, "receive_remove from %d not found %s",
4436 from_nodeid, name);
4437 spin_unlock(&ls->ls_rsbtbl[b].lock);
4438 return;
4439 }
4440 if (r->res_master_nodeid != from_nodeid) {
4441 /* should not happen */
4442 log_error(ls, "receive_remove keep from %d master %d",
4443 from_nodeid, r->res_master_nodeid);
4444 dlm_print_rsb(r);
4445 spin_unlock(&ls->ls_rsbtbl[b].lock);
4446 return;
4447 }
4448
4449 log_debug(ls, "receive_remove from %d master %d first %x %s",
4450 from_nodeid, r->res_master_nodeid, r->res_first_lkid,
4451 name);
4452 spin_unlock(&ls->ls_rsbtbl[b].lock);
4453 return;
4454 }
4455
4456 if (r->res_master_nodeid != from_nodeid) {
4457 log_error(ls, "receive_remove toss from %d master %d",
4458 from_nodeid, r->res_master_nodeid);
4459 dlm_print_rsb(r);
4460 spin_unlock(&ls->ls_rsbtbl[b].lock);
4461 return;
4462 }
4463
4464 if (kref_put(&r->res_ref, kill_rsb)) {
4465 rb_erase(&r->res_hashnode, &ls->ls_rsbtbl[b].toss);
4466 spin_unlock(&ls->ls_rsbtbl[b].lock);
4467 dlm_free_rsb(r);
4468 } else {
4469 log_error(ls, "receive_remove from %d rsb ref error",
4470 from_nodeid);
4471 dlm_print_rsb(r);
4472 spin_unlock(&ls->ls_rsbtbl[b].lock);
4473 }
David Teiglande7fd4172006-01-18 09:30:29 +00004474}
4475
David Teigland84991372007-03-30 15:02:40 -05004476static void receive_purge(struct dlm_ls *ls, struct dlm_message *ms)
4477{
4478 do_purge(ls, ms->m_nodeid, ms->m_pid);
4479}
4480
David Teigland6d40c4a2012-04-23 16:36:01 -05004481static int receive_request_reply(struct dlm_ls *ls, struct dlm_message *ms)
David Teiglande7fd4172006-01-18 09:30:29 +00004482{
4483 struct dlm_lkb *lkb;
4484 struct dlm_rsb *r;
David Teiglandef0c2bb2007-03-28 09:56:46 -05004485 int error, mstype, result;
David Teiglandc04fecb2012-05-10 10:18:07 -05004486 int from_nodeid = ms->m_header.h_nodeid;
David Teiglande7fd4172006-01-18 09:30:29 +00004487
4488 error = find_lkb(ls, ms->m_remid, &lkb);
David Teigland6d40c4a2012-04-23 16:36:01 -05004489 if (error)
4490 return error;
David Teiglande7fd4172006-01-18 09:30:29 +00004491
David Teiglande7fd4172006-01-18 09:30:29 +00004492 r = lkb->lkb_resource;
4493 hold_rsb(r);
4494 lock_rsb(r);
4495
David Teiglandc54e04b2008-01-09 09:59:41 -06004496 error = validate_message(lkb, ms);
4497 if (error)
4498 goto out;
4499
David Teiglandef0c2bb2007-03-28 09:56:46 -05004500 mstype = lkb->lkb_wait_type;
4501 error = remove_from_waiters(lkb, DLM_MSG_REQUEST_REPLY);
David Teigland48756472012-04-26 15:54:29 -05004502 if (error) {
4503 log_error(ls, "receive_request_reply %x remote %d %x result %d",
David Teiglandc04fecb2012-05-10 10:18:07 -05004504 lkb->lkb_id, from_nodeid, ms->m_lkid, ms->m_result);
David Teigland48756472012-04-26 15:54:29 -05004505 dlm_dump_rsb(r);
David Teiglandef0c2bb2007-03-28 09:56:46 -05004506 goto out;
David Teigland48756472012-04-26 15:54:29 -05004507 }
David Teiglandef0c2bb2007-03-28 09:56:46 -05004508
David Teiglande7fd4172006-01-18 09:30:29 +00004509 /* Optimization: the dir node was also the master, so it took our
4510 lookup as a request and sent request reply instead of lookup reply */
4511 if (mstype == DLM_MSG_LOOKUP) {
David Teiglandc04fecb2012-05-10 10:18:07 -05004512 r->res_master_nodeid = from_nodeid;
4513 r->res_nodeid = from_nodeid;
4514 lkb->lkb_nodeid = from_nodeid;
David Teiglande7fd4172006-01-18 09:30:29 +00004515 }
4516
David Teiglandef0c2bb2007-03-28 09:56:46 -05004517 /* this is the value returned from do_request() on the master */
4518 result = ms->m_result;
4519
4520 switch (result) {
David Teiglande7fd4172006-01-18 09:30:29 +00004521 case -EAGAIN:
David Teiglandef0c2bb2007-03-28 09:56:46 -05004522 /* request would block (be queued) on remote master */
David Teiglande7fd4172006-01-18 09:30:29 +00004523 queue_cast(r, lkb, -EAGAIN);
4524 confirm_master(r, -EAGAIN);
David Teiglandef0c2bb2007-03-28 09:56:46 -05004525 unhold_lkb(lkb); /* undoes create_lkb() */
David Teiglande7fd4172006-01-18 09:30:29 +00004526 break;
4527
4528 case -EINPROGRESS:
4529 case 0:
4530 /* request was queued or granted on remote master */
4531 receive_flags_reply(lkb, ms);
4532 lkb->lkb_remid = ms->m_lkid;
David Teigland7d3c1fe2007-04-19 10:30:41 -05004533 if (is_altmode(lkb))
4534 munge_altmode(lkb, ms);
David Teigland3ae1acf2007-05-18 08:59:31 -05004535 if (result) {
David Teiglande7fd4172006-01-18 09:30:29 +00004536 add_lkb(r, lkb, DLM_LKSTS_WAITING);
David Teigland3ae1acf2007-05-18 08:59:31 -05004537 add_timeout(lkb);
4538 } else {
David Teiglande7fd4172006-01-18 09:30:29 +00004539 grant_lock_pc(r, lkb, ms);
4540 queue_cast(r, lkb, 0);
4541 }
David Teiglandef0c2bb2007-03-28 09:56:46 -05004542 confirm_master(r, result);
David Teiglande7fd4172006-01-18 09:30:29 +00004543 break;
4544
David Teigland597d0ca2006-07-12 16:44:04 -05004545 case -EBADR:
David Teiglande7fd4172006-01-18 09:30:29 +00004546 case -ENOTBLK:
4547 /* find_rsb failed to find rsb or rsb wasn't master */
David Teiglandc04fecb2012-05-10 10:18:07 -05004548 log_limit(ls, "receive_request_reply %x from %d %d "
4549 "master %d dir %d first %x %s", lkb->lkb_id,
4550 from_nodeid, result, r->res_master_nodeid,
4551 r->res_dir_nodeid, r->res_first_lkid, r->res_name);
4552
4553 if (r->res_dir_nodeid != dlm_our_nodeid() &&
4554 r->res_master_nodeid != dlm_our_nodeid()) {
4555 /* cause _request_lock->set_master->send_lookup */
4556 r->res_master_nodeid = 0;
4557 r->res_nodeid = -1;
4558 lkb->lkb_nodeid = -1;
4559 }
David Teiglandef0c2bb2007-03-28 09:56:46 -05004560
4561 if (is_overlap(lkb)) {
4562 /* we'll ignore error in cancel/unlock reply */
4563 queue_cast_overlap(r, lkb);
David Teiglandaec64e12008-01-08 15:37:47 -06004564 confirm_master(r, result);
David Teiglandef0c2bb2007-03-28 09:56:46 -05004565 unhold_lkb(lkb); /* undoes create_lkb() */
David Teiglandc04fecb2012-05-10 10:18:07 -05004566 } else {
David Teiglandef0c2bb2007-03-28 09:56:46 -05004567 _request_lock(r, lkb);
David Teiglandc04fecb2012-05-10 10:18:07 -05004568
4569 if (r->res_master_nodeid == dlm_our_nodeid())
4570 confirm_master(r, 0);
4571 }
David Teiglande7fd4172006-01-18 09:30:29 +00004572 break;
4573
4574 default:
David Teiglandef0c2bb2007-03-28 09:56:46 -05004575 log_error(ls, "receive_request_reply %x error %d",
4576 lkb->lkb_id, result);
David Teiglande7fd4172006-01-18 09:30:29 +00004577 }
4578
David Teiglandef0c2bb2007-03-28 09:56:46 -05004579 if (is_overlap_unlock(lkb) && (result == 0 || result == -EINPROGRESS)) {
4580 log_debug(ls, "receive_request_reply %x result %d unlock",
4581 lkb->lkb_id, result);
4582 lkb->lkb_flags &= ~DLM_IFL_OVERLAP_UNLOCK;
4583 lkb->lkb_flags &= ~DLM_IFL_OVERLAP_CANCEL;
4584 send_unlock(r, lkb);
4585 } else if (is_overlap_cancel(lkb) && (result == -EINPROGRESS)) {
4586 log_debug(ls, "receive_request_reply %x cancel", lkb->lkb_id);
4587 lkb->lkb_flags &= ~DLM_IFL_OVERLAP_UNLOCK;
4588 lkb->lkb_flags &= ~DLM_IFL_OVERLAP_CANCEL;
4589 send_cancel(r, lkb);
4590 } else {
4591 lkb->lkb_flags &= ~DLM_IFL_OVERLAP_CANCEL;
4592 lkb->lkb_flags &= ~DLM_IFL_OVERLAP_UNLOCK;
4593 }
4594 out:
David Teiglande7fd4172006-01-18 09:30:29 +00004595 unlock_rsb(r);
4596 put_rsb(r);
David Teiglandb3f58d82006-02-28 11:16:37 -05004597 dlm_put_lkb(lkb);
David Teigland6d40c4a2012-04-23 16:36:01 -05004598 return 0;
David Teiglande7fd4172006-01-18 09:30:29 +00004599}
4600
4601static void __receive_convert_reply(struct dlm_rsb *r, struct dlm_lkb *lkb,
4602 struct dlm_message *ms)
4603{
David Teiglande7fd4172006-01-18 09:30:29 +00004604 /* this is the value returned from do_convert() on the master */
David Teiglandef0c2bb2007-03-28 09:56:46 -05004605 switch (ms->m_result) {
David Teiglande7fd4172006-01-18 09:30:29 +00004606 case -EAGAIN:
4607 /* convert would block (be queued) on remote master */
4608 queue_cast(r, lkb, -EAGAIN);
4609 break;
4610
David Teiglandc85d65e2007-05-18 09:01:26 -05004611 case -EDEADLK:
4612 receive_flags_reply(lkb, ms);
4613 revert_lock_pc(r, lkb);
4614 queue_cast(r, lkb, -EDEADLK);
4615 break;
4616
David Teiglande7fd4172006-01-18 09:30:29 +00004617 case -EINPROGRESS:
4618 /* convert was queued on remote master */
David Teigland7d3c1fe2007-04-19 10:30:41 -05004619 receive_flags_reply(lkb, ms);
4620 if (is_demoted(lkb))
David Teigland2a7ce0e2011-04-04 15:19:59 -05004621 munge_demoted(lkb);
David Teiglande7fd4172006-01-18 09:30:29 +00004622 del_lkb(r, lkb);
4623 add_lkb(r, lkb, DLM_LKSTS_CONVERT);
David Teigland3ae1acf2007-05-18 08:59:31 -05004624 add_timeout(lkb);
David Teiglande7fd4172006-01-18 09:30:29 +00004625 break;
4626
4627 case 0:
4628 /* convert was granted on remote master */
4629 receive_flags_reply(lkb, ms);
David Teigland7d3c1fe2007-04-19 10:30:41 -05004630 if (is_demoted(lkb))
David Teigland2a7ce0e2011-04-04 15:19:59 -05004631 munge_demoted(lkb);
David Teiglande7fd4172006-01-18 09:30:29 +00004632 grant_lock_pc(r, lkb, ms);
4633 queue_cast(r, lkb, 0);
4634 break;
4635
4636 default:
David Teigland6d40c4a2012-04-23 16:36:01 -05004637 log_error(r->res_ls, "receive_convert_reply %x remote %d %x %d",
4638 lkb->lkb_id, ms->m_header.h_nodeid, ms->m_lkid,
4639 ms->m_result);
4640 dlm_print_rsb(r);
4641 dlm_print_lkb(lkb);
David Teiglande7fd4172006-01-18 09:30:29 +00004642 }
4643}
4644
4645static void _receive_convert_reply(struct dlm_lkb *lkb, struct dlm_message *ms)
4646{
4647 struct dlm_rsb *r = lkb->lkb_resource;
David Teiglandef0c2bb2007-03-28 09:56:46 -05004648 int error;
David Teiglande7fd4172006-01-18 09:30:29 +00004649
4650 hold_rsb(r);
4651 lock_rsb(r);
4652
David Teiglandc54e04b2008-01-09 09:59:41 -06004653 error = validate_message(lkb, ms);
4654 if (error)
4655 goto out;
4656
David Teiglandef0c2bb2007-03-28 09:56:46 -05004657 /* stub reply can happen with waiters_mutex held */
4658 error = remove_from_waiters_ms(lkb, ms);
4659 if (error)
4660 goto out;
David Teiglande7fd4172006-01-18 09:30:29 +00004661
David Teiglandef0c2bb2007-03-28 09:56:46 -05004662 __receive_convert_reply(r, lkb, ms);
4663 out:
David Teiglande7fd4172006-01-18 09:30:29 +00004664 unlock_rsb(r);
4665 put_rsb(r);
4666}
4667
David Teigland6d40c4a2012-04-23 16:36:01 -05004668static int receive_convert_reply(struct dlm_ls *ls, struct dlm_message *ms)
David Teiglande7fd4172006-01-18 09:30:29 +00004669{
4670 struct dlm_lkb *lkb;
4671 int error;
4672
4673 error = find_lkb(ls, ms->m_remid, &lkb);
David Teigland6d40c4a2012-04-23 16:36:01 -05004674 if (error)
4675 return error;
David Teiglande7fd4172006-01-18 09:30:29 +00004676
David Teiglande7fd4172006-01-18 09:30:29 +00004677 _receive_convert_reply(lkb, ms);
David Teiglandb3f58d82006-02-28 11:16:37 -05004678 dlm_put_lkb(lkb);
David Teigland6d40c4a2012-04-23 16:36:01 -05004679 return 0;
David Teiglande7fd4172006-01-18 09:30:29 +00004680}
4681
4682static void _receive_unlock_reply(struct dlm_lkb *lkb, struct dlm_message *ms)
4683{
4684 struct dlm_rsb *r = lkb->lkb_resource;
David Teiglandef0c2bb2007-03-28 09:56:46 -05004685 int error;
David Teiglande7fd4172006-01-18 09:30:29 +00004686
4687 hold_rsb(r);
4688 lock_rsb(r);
4689
David Teiglandc54e04b2008-01-09 09:59:41 -06004690 error = validate_message(lkb, ms);
4691 if (error)
4692 goto out;
4693
David Teiglandef0c2bb2007-03-28 09:56:46 -05004694 /* stub reply can happen with waiters_mutex held */
4695 error = remove_from_waiters_ms(lkb, ms);
4696 if (error)
4697 goto out;
4698
David Teiglande7fd4172006-01-18 09:30:29 +00004699 /* this is the value returned from do_unlock() on the master */
4700
David Teiglandef0c2bb2007-03-28 09:56:46 -05004701 switch (ms->m_result) {
David Teiglande7fd4172006-01-18 09:30:29 +00004702 case -DLM_EUNLOCK:
4703 receive_flags_reply(lkb, ms);
4704 remove_lock_pc(r, lkb);
4705 queue_cast(r, lkb, -DLM_EUNLOCK);
4706 break;
David Teiglandef0c2bb2007-03-28 09:56:46 -05004707 case -ENOENT:
4708 break;
David Teiglande7fd4172006-01-18 09:30:29 +00004709 default:
David Teiglandef0c2bb2007-03-28 09:56:46 -05004710 log_error(r->res_ls, "receive_unlock_reply %x error %d",
4711 lkb->lkb_id, ms->m_result);
David Teiglande7fd4172006-01-18 09:30:29 +00004712 }
David Teiglandef0c2bb2007-03-28 09:56:46 -05004713 out:
David Teiglande7fd4172006-01-18 09:30:29 +00004714 unlock_rsb(r);
4715 put_rsb(r);
4716}
4717
David Teigland6d40c4a2012-04-23 16:36:01 -05004718static int receive_unlock_reply(struct dlm_ls *ls, struct dlm_message *ms)
David Teiglande7fd4172006-01-18 09:30:29 +00004719{
4720 struct dlm_lkb *lkb;
4721 int error;
4722
4723 error = find_lkb(ls, ms->m_remid, &lkb);
David Teigland6d40c4a2012-04-23 16:36:01 -05004724 if (error)
4725 return error;
David Teiglande7fd4172006-01-18 09:30:29 +00004726
David Teiglande7fd4172006-01-18 09:30:29 +00004727 _receive_unlock_reply(lkb, ms);
David Teiglandb3f58d82006-02-28 11:16:37 -05004728 dlm_put_lkb(lkb);
David Teigland6d40c4a2012-04-23 16:36:01 -05004729 return 0;
David Teiglande7fd4172006-01-18 09:30:29 +00004730}
4731
4732static void _receive_cancel_reply(struct dlm_lkb *lkb, struct dlm_message *ms)
4733{
4734 struct dlm_rsb *r = lkb->lkb_resource;
David Teiglandef0c2bb2007-03-28 09:56:46 -05004735 int error;
David Teiglande7fd4172006-01-18 09:30:29 +00004736
4737 hold_rsb(r);
4738 lock_rsb(r);
4739
David Teiglandc54e04b2008-01-09 09:59:41 -06004740 error = validate_message(lkb, ms);
4741 if (error)
4742 goto out;
4743
David Teiglandef0c2bb2007-03-28 09:56:46 -05004744 /* stub reply can happen with waiters_mutex held */
4745 error = remove_from_waiters_ms(lkb, ms);
4746 if (error)
4747 goto out;
4748
David Teiglande7fd4172006-01-18 09:30:29 +00004749 /* this is the value returned from do_cancel() on the master */
4750
David Teiglandef0c2bb2007-03-28 09:56:46 -05004751 switch (ms->m_result) {
David Teiglande7fd4172006-01-18 09:30:29 +00004752 case -DLM_ECANCEL:
4753 receive_flags_reply(lkb, ms);
4754 revert_lock_pc(r, lkb);
David Teigland84d8cd62007-05-29 08:44:23 -05004755 queue_cast(r, lkb, -DLM_ECANCEL);
David Teiglandef0c2bb2007-03-28 09:56:46 -05004756 break;
4757 case 0:
David Teiglande7fd4172006-01-18 09:30:29 +00004758 break;
4759 default:
David Teiglandef0c2bb2007-03-28 09:56:46 -05004760 log_error(r->res_ls, "receive_cancel_reply %x error %d",
4761 lkb->lkb_id, ms->m_result);
David Teiglande7fd4172006-01-18 09:30:29 +00004762 }
David Teiglandef0c2bb2007-03-28 09:56:46 -05004763 out:
David Teiglande7fd4172006-01-18 09:30:29 +00004764 unlock_rsb(r);
4765 put_rsb(r);
4766}
4767
David Teigland6d40c4a2012-04-23 16:36:01 -05004768static int receive_cancel_reply(struct dlm_ls *ls, struct dlm_message *ms)
David Teiglande7fd4172006-01-18 09:30:29 +00004769{
4770 struct dlm_lkb *lkb;
4771 int error;
4772
4773 error = find_lkb(ls, ms->m_remid, &lkb);
David Teigland6d40c4a2012-04-23 16:36:01 -05004774 if (error)
4775 return error;
David Teiglande7fd4172006-01-18 09:30:29 +00004776
David Teiglande7fd4172006-01-18 09:30:29 +00004777 _receive_cancel_reply(lkb, ms);
David Teiglandb3f58d82006-02-28 11:16:37 -05004778 dlm_put_lkb(lkb);
David Teigland6d40c4a2012-04-23 16:36:01 -05004779 return 0;
David Teiglande7fd4172006-01-18 09:30:29 +00004780}
4781
4782static void receive_lookup_reply(struct dlm_ls *ls, struct dlm_message *ms)
4783{
4784 struct dlm_lkb *lkb;
4785 struct dlm_rsb *r;
4786 int error, ret_nodeid;
David Teiglandc04fecb2012-05-10 10:18:07 -05004787 int do_lookup_list = 0;
David Teiglande7fd4172006-01-18 09:30:29 +00004788
4789 error = find_lkb(ls, ms->m_lkid, &lkb);
4790 if (error) {
David Teigland6d40c4a2012-04-23 16:36:01 -05004791 log_error(ls, "receive_lookup_reply no lkid %x", ms->m_lkid);
David Teiglande7fd4172006-01-18 09:30:29 +00004792 return;
4793 }
4794
David Teiglandc04fecb2012-05-10 10:18:07 -05004795 /* ms->m_result is the value returned by dlm_master_lookup on dir node
David Teiglande7fd4172006-01-18 09:30:29 +00004796 FIXME: will a non-zero error ever be returned? */
David Teiglande7fd4172006-01-18 09:30:29 +00004797
4798 r = lkb->lkb_resource;
4799 hold_rsb(r);
4800 lock_rsb(r);
4801
David Teiglandef0c2bb2007-03-28 09:56:46 -05004802 error = remove_from_waiters(lkb, DLM_MSG_LOOKUP_REPLY);
4803 if (error)
4804 goto out;
4805
David Teiglande7fd4172006-01-18 09:30:29 +00004806 ret_nodeid = ms->m_nodeid;
David Teiglandc04fecb2012-05-10 10:18:07 -05004807
4808 /* We sometimes receive a request from the dir node for this
4809 rsb before we've received the dir node's loookup_reply for it.
4810 The request from the dir node implies we're the master, so we set
4811 ourself as master in receive_request_reply, and verify here that
4812 we are indeed the master. */
4813
4814 if (r->res_master_nodeid && (r->res_master_nodeid != ret_nodeid)) {
4815 /* This should never happen */
4816 log_error(ls, "receive_lookup_reply %x from %d ret %d "
4817 "master %d dir %d our %d first %x %s",
4818 lkb->lkb_id, ms->m_header.h_nodeid, ret_nodeid,
4819 r->res_master_nodeid, r->res_dir_nodeid,
4820 dlm_our_nodeid(), r->res_first_lkid, r->res_name);
4821 }
4822
David Teiglande7fd4172006-01-18 09:30:29 +00004823 if (ret_nodeid == dlm_our_nodeid()) {
David Teiglandc04fecb2012-05-10 10:18:07 -05004824 r->res_master_nodeid = ret_nodeid;
David Teiglande7fd4172006-01-18 09:30:29 +00004825 r->res_nodeid = 0;
David Teiglandc04fecb2012-05-10 10:18:07 -05004826 do_lookup_list = 1;
David Teiglande7fd4172006-01-18 09:30:29 +00004827 r->res_first_lkid = 0;
David Teiglandc04fecb2012-05-10 10:18:07 -05004828 } else if (ret_nodeid == -1) {
4829 /* the remote node doesn't believe it's the dir node */
4830 log_error(ls, "receive_lookup_reply %x from %d bad ret_nodeid",
4831 lkb->lkb_id, ms->m_header.h_nodeid);
4832 r->res_master_nodeid = 0;
4833 r->res_nodeid = -1;
4834 lkb->lkb_nodeid = -1;
David Teiglande7fd4172006-01-18 09:30:29 +00004835 } else {
David Teiglandc04fecb2012-05-10 10:18:07 -05004836 /* set_master() will set lkb_nodeid from r */
4837 r->res_master_nodeid = ret_nodeid;
David Teiglande7fd4172006-01-18 09:30:29 +00004838 r->res_nodeid = ret_nodeid;
4839 }
4840
David Teiglandef0c2bb2007-03-28 09:56:46 -05004841 if (is_overlap(lkb)) {
4842 log_debug(ls, "receive_lookup_reply %x unlock %x",
4843 lkb->lkb_id, lkb->lkb_flags);
4844 queue_cast_overlap(r, lkb);
4845 unhold_lkb(lkb); /* undoes create_lkb() */
4846 goto out_list;
4847 }
4848
David Teiglande7fd4172006-01-18 09:30:29 +00004849 _request_lock(r, lkb);
4850
David Teiglandef0c2bb2007-03-28 09:56:46 -05004851 out_list:
David Teiglandc04fecb2012-05-10 10:18:07 -05004852 if (do_lookup_list)
David Teiglande7fd4172006-01-18 09:30:29 +00004853 process_lookup_list(r);
David Teiglandef0c2bb2007-03-28 09:56:46 -05004854 out:
David Teiglande7fd4172006-01-18 09:30:29 +00004855 unlock_rsb(r);
4856 put_rsb(r);
David Teiglandb3f58d82006-02-28 11:16:37 -05004857 dlm_put_lkb(lkb);
David Teiglande7fd4172006-01-18 09:30:29 +00004858}
4859
David Teigland6d40c4a2012-04-23 16:36:01 -05004860static void _receive_message(struct dlm_ls *ls, struct dlm_message *ms,
4861 uint32_t saved_seq)
David Teiglande7fd4172006-01-18 09:30:29 +00004862{
David Teigland6d40c4a2012-04-23 16:36:01 -05004863 int error = 0, noent = 0;
4864
David Teigland46b43ee2008-01-08 16:24:00 -06004865 if (!dlm_is_member(ls, ms->m_header.h_nodeid)) {
David Teiglandc04fecb2012-05-10 10:18:07 -05004866 log_limit(ls, "receive %d from non-member %d %x %x %d",
David Teigland46b43ee2008-01-08 16:24:00 -06004867 ms->m_type, ms->m_header.h_nodeid, ms->m_lkid,
4868 ms->m_remid, ms->m_result);
4869 return;
4870 }
4871
David Teiglande7fd4172006-01-18 09:30:29 +00004872 switch (ms->m_type) {
4873
4874 /* messages sent to a master node */
4875
4876 case DLM_MSG_REQUEST:
David Teigland6d40c4a2012-04-23 16:36:01 -05004877 error = receive_request(ls, ms);
David Teiglande7fd4172006-01-18 09:30:29 +00004878 break;
4879
4880 case DLM_MSG_CONVERT:
David Teigland6d40c4a2012-04-23 16:36:01 -05004881 error = receive_convert(ls, ms);
David Teiglande7fd4172006-01-18 09:30:29 +00004882 break;
4883
4884 case DLM_MSG_UNLOCK:
David Teigland6d40c4a2012-04-23 16:36:01 -05004885 error = receive_unlock(ls, ms);
David Teiglande7fd4172006-01-18 09:30:29 +00004886 break;
4887
4888 case DLM_MSG_CANCEL:
David Teigland6d40c4a2012-04-23 16:36:01 -05004889 noent = 1;
4890 error = receive_cancel(ls, ms);
David Teiglande7fd4172006-01-18 09:30:29 +00004891 break;
4892
4893 /* messages sent from a master node (replies to above) */
4894
4895 case DLM_MSG_REQUEST_REPLY:
David Teigland6d40c4a2012-04-23 16:36:01 -05004896 error = receive_request_reply(ls, ms);
David Teiglande7fd4172006-01-18 09:30:29 +00004897 break;
4898
4899 case DLM_MSG_CONVERT_REPLY:
David Teigland6d40c4a2012-04-23 16:36:01 -05004900 error = receive_convert_reply(ls, ms);
David Teiglande7fd4172006-01-18 09:30:29 +00004901 break;
4902
4903 case DLM_MSG_UNLOCK_REPLY:
David Teigland6d40c4a2012-04-23 16:36:01 -05004904 error = receive_unlock_reply(ls, ms);
David Teiglande7fd4172006-01-18 09:30:29 +00004905 break;
4906
4907 case DLM_MSG_CANCEL_REPLY:
David Teigland6d40c4a2012-04-23 16:36:01 -05004908 error = receive_cancel_reply(ls, ms);
David Teiglande7fd4172006-01-18 09:30:29 +00004909 break;
4910
4911 /* messages sent from a master node (only two types of async msg) */
4912
4913 case DLM_MSG_GRANT:
David Teigland6d40c4a2012-04-23 16:36:01 -05004914 noent = 1;
4915 error = receive_grant(ls, ms);
David Teiglande7fd4172006-01-18 09:30:29 +00004916 break;
4917
4918 case DLM_MSG_BAST:
David Teigland6d40c4a2012-04-23 16:36:01 -05004919 noent = 1;
4920 error = receive_bast(ls, ms);
David Teiglande7fd4172006-01-18 09:30:29 +00004921 break;
4922
4923 /* messages sent to a dir node */
4924
4925 case DLM_MSG_LOOKUP:
4926 receive_lookup(ls, ms);
4927 break;
4928
4929 case DLM_MSG_REMOVE:
4930 receive_remove(ls, ms);
4931 break;
4932
4933 /* messages sent from a dir node (remove has no reply) */
4934
4935 case DLM_MSG_LOOKUP_REPLY:
4936 receive_lookup_reply(ls, ms);
4937 break;
4938
David Teigland84991372007-03-30 15:02:40 -05004939 /* other messages */
4940
4941 case DLM_MSG_PURGE:
4942 receive_purge(ls, ms);
4943 break;
4944
David Teiglande7fd4172006-01-18 09:30:29 +00004945 default:
4946 log_error(ls, "unknown message type %d", ms->m_type);
4947 }
David Teigland6d40c4a2012-04-23 16:36:01 -05004948
4949 /*
4950 * When checking for ENOENT, we're checking the result of
4951 * find_lkb(m_remid):
4952 *
4953 * The lock id referenced in the message wasn't found. This may
4954 * happen in normal usage for the async messages and cancel, so
4955 * only use log_debug for them.
4956 *
David Teigland48756472012-04-26 15:54:29 -05004957 * Some errors are expected and normal.
David Teigland6d40c4a2012-04-23 16:36:01 -05004958 */
4959
4960 if (error == -ENOENT && noent) {
David Teigland48756472012-04-26 15:54:29 -05004961 log_debug(ls, "receive %d no %x remote %d %x saved_seq %u",
David Teigland6d40c4a2012-04-23 16:36:01 -05004962 ms->m_type, ms->m_remid, ms->m_header.h_nodeid,
4963 ms->m_lkid, saved_seq);
4964 } else if (error == -ENOENT) {
David Teigland48756472012-04-26 15:54:29 -05004965 log_error(ls, "receive %d no %x remote %d %x saved_seq %u",
David Teigland6d40c4a2012-04-23 16:36:01 -05004966 ms->m_type, ms->m_remid, ms->m_header.h_nodeid,
4967 ms->m_lkid, saved_seq);
4968
4969 if (ms->m_type == DLM_MSG_CONVERT)
4970 dlm_dump_rsb_hash(ls, ms->m_hash);
4971 }
David Teigland48756472012-04-26 15:54:29 -05004972
4973 if (error == -EINVAL) {
4974 log_error(ls, "receive %d inval from %d lkid %x remid %x "
4975 "saved_seq %u",
4976 ms->m_type, ms->m_header.h_nodeid,
4977 ms->m_lkid, ms->m_remid, saved_seq);
4978 }
David Teiglande7fd4172006-01-18 09:30:29 +00004979}
4980
David Teiglandc36258b2007-09-27 15:53:38 -05004981/* If the lockspace is in recovery mode (locking stopped), then normal
4982 messages are saved on the requestqueue for processing after recovery is
4983 done. When not in recovery mode, we wait for dlm_recoverd to drain saved
4984 messages off the requestqueue before we process new ones. This occurs right
4985 after recovery completes when we transition from saving all messages on
4986 requestqueue, to processing all the saved messages, to processing new
4987 messages as they arrive. */
David Teiglande7fd4172006-01-18 09:30:29 +00004988
David Teiglandc36258b2007-09-27 15:53:38 -05004989static void dlm_receive_message(struct dlm_ls *ls, struct dlm_message *ms,
4990 int nodeid)
4991{
4992 if (dlm_locking_stopped(ls)) {
David Teiglandc04fecb2012-05-10 10:18:07 -05004993 /* If we were a member of this lockspace, left, and rejoined,
4994 other nodes may still be sending us messages from the
4995 lockspace generation before we left. */
4996 if (!ls->ls_generation) {
4997 log_limit(ls, "receive %d from %d ignore old gen",
4998 ms->m_type, nodeid);
4999 return;
5000 }
5001
Al Viro8b0d8e02008-01-25 00:28:28 -05005002 dlm_add_requestqueue(ls, nodeid, ms);
David Teiglandc36258b2007-09-27 15:53:38 -05005003 } else {
5004 dlm_wait_requestqueue(ls);
David Teigland6d40c4a2012-04-23 16:36:01 -05005005 _receive_message(ls, ms, 0);
David Teiglandc36258b2007-09-27 15:53:38 -05005006 }
5007}
5008
5009/* This is called by dlm_recoverd to process messages that were saved on
5010 the requestqueue. */
5011
David Teigland6d40c4a2012-04-23 16:36:01 -05005012void dlm_receive_message_saved(struct dlm_ls *ls, struct dlm_message *ms,
5013 uint32_t saved_seq)
David Teiglandc36258b2007-09-27 15:53:38 -05005014{
David Teigland6d40c4a2012-04-23 16:36:01 -05005015 _receive_message(ls, ms, saved_seq);
David Teiglandc36258b2007-09-27 15:53:38 -05005016}
5017
5018/* This is called by the midcomms layer when something is received for
5019 the lockspace. It could be either a MSG (normal message sent as part of
5020 standard locking activity) or an RCOM (recovery message sent as part of
5021 lockspace recovery). */
5022
Al Viroeef7d732008-01-25 00:58:46 -05005023void dlm_receive_buffer(union dlm_packet *p, int nodeid)
David Teiglandc36258b2007-09-27 15:53:38 -05005024{
Al Viroeef7d732008-01-25 00:58:46 -05005025 struct dlm_header *hd = &p->header;
David Teiglandc36258b2007-09-27 15:53:38 -05005026 struct dlm_ls *ls;
5027 int type = 0;
5028
5029 switch (hd->h_cmd) {
5030 case DLM_MSG:
Al Viroeef7d732008-01-25 00:58:46 -05005031 dlm_message_in(&p->message);
5032 type = p->message.m_type;
David Teiglandc36258b2007-09-27 15:53:38 -05005033 break;
5034 case DLM_RCOM:
Al Viroeef7d732008-01-25 00:58:46 -05005035 dlm_rcom_in(&p->rcom);
5036 type = p->rcom.rc_type;
David Teiglandc36258b2007-09-27 15:53:38 -05005037 break;
5038 default:
5039 log_print("invalid h_cmd %d from %u", hd->h_cmd, nodeid);
5040 return;
5041 }
5042
5043 if (hd->h_nodeid != nodeid) {
5044 log_print("invalid h_nodeid %d from %d lockspace %x",
5045 hd->h_nodeid, nodeid, hd->h_lockspace);
5046 return;
5047 }
5048
5049 ls = dlm_find_lockspace_global(hd->h_lockspace);
5050 if (!ls) {
David Teigland48756472012-04-26 15:54:29 -05005051 if (dlm_config.ci_log_debug) {
5052 printk_ratelimited(KERN_DEBUG "dlm: invalid lockspace "
5053 "%u from %d cmd %d type %d\n",
5054 hd->h_lockspace, nodeid, hd->h_cmd, type);
5055 }
David Teiglandc36258b2007-09-27 15:53:38 -05005056
5057 if (hd->h_cmd == DLM_RCOM && type == DLM_RCOM_STATUS)
Al Viroeef7d732008-01-25 00:58:46 -05005058 dlm_send_ls_not_ready(nodeid, &p->rcom);
David Teiglandc36258b2007-09-27 15:53:38 -05005059 return;
5060 }
5061
5062 /* this rwsem allows dlm_ls_stop() to wait for all dlm_recv threads to
5063 be inactive (in this ls) before transitioning to recovery mode */
5064
5065 down_read(&ls->ls_recv_active);
5066 if (hd->h_cmd == DLM_MSG)
Al Viroeef7d732008-01-25 00:58:46 -05005067 dlm_receive_message(ls, &p->message, nodeid);
David Teiglandc36258b2007-09-27 15:53:38 -05005068 else
Al Viroeef7d732008-01-25 00:58:46 -05005069 dlm_receive_rcom(ls, &p->rcom, nodeid);
David Teiglandc36258b2007-09-27 15:53:38 -05005070 up_read(&ls->ls_recv_active);
5071
5072 dlm_put_lockspace(ls);
5073}
David Teiglande7fd4172006-01-18 09:30:29 +00005074
David Teigland2a7ce0e2011-04-04 15:19:59 -05005075static void recover_convert_waiter(struct dlm_ls *ls, struct dlm_lkb *lkb,
5076 struct dlm_message *ms_stub)
David Teiglande7fd4172006-01-18 09:30:29 +00005077{
5078 if (middle_conversion(lkb)) {
5079 hold_lkb(lkb);
David Teigland2a7ce0e2011-04-04 15:19:59 -05005080 memset(ms_stub, 0, sizeof(struct dlm_message));
5081 ms_stub->m_flags = DLM_IFL_STUB_MS;
5082 ms_stub->m_type = DLM_MSG_CONVERT_REPLY;
5083 ms_stub->m_result = -EINPROGRESS;
5084 ms_stub->m_header.h_nodeid = lkb->lkb_nodeid;
5085 _receive_convert_reply(lkb, ms_stub);
David Teiglande7fd4172006-01-18 09:30:29 +00005086
5087 /* Same special case as in receive_rcom_lock_args() */
5088 lkb->lkb_grmode = DLM_LOCK_IV;
5089 rsb_set_flag(lkb->lkb_resource, RSB_RECOVER_CONVERT);
5090 unhold_lkb(lkb);
5091
5092 } else if (lkb->lkb_rqmode >= lkb->lkb_grmode) {
5093 lkb->lkb_flags |= DLM_IFL_RESEND;
5094 }
5095
5096 /* lkb->lkb_rqmode < lkb->lkb_grmode shouldn't happen since down
5097 conversions are async; there's no reply from the remote master */
5098}
5099
5100/* A waiting lkb needs recovery if the master node has failed, or
5101 the master node is changing (only when no directory is used) */
5102
David Teigland13ef1112012-04-23 12:18:18 -05005103static int waiter_needs_recovery(struct dlm_ls *ls, struct dlm_lkb *lkb,
5104 int dir_nodeid)
David Teiglande7fd4172006-01-18 09:30:29 +00005105{
David Teigland48756472012-04-26 15:54:29 -05005106 if (dlm_no_directory(ls))
5107 return 1;
5108
David Teigland13ef1112012-04-23 12:18:18 -05005109 if (dlm_is_removed(ls, lkb->lkb_wait_nodeid))
David Teiglande7fd4172006-01-18 09:30:29 +00005110 return 1;
5111
David Teiglande7fd4172006-01-18 09:30:29 +00005112 return 0;
5113}
5114
5115/* Recovery for locks that are waiting for replies from nodes that are now
5116 gone. We can just complete unlocks and cancels by faking a reply from the
5117 dead node. Requests and up-conversions we flag to be resent after
5118 recovery. Down-conversions can just be completed with a fake reply like
5119 unlocks. Conversions between PR and CW need special attention. */
5120
5121void dlm_recover_waiters_pre(struct dlm_ls *ls)
5122{
5123 struct dlm_lkb *lkb, *safe;
David Teigland2a7ce0e2011-04-04 15:19:59 -05005124 struct dlm_message *ms_stub;
David Teigland601342c2008-01-07 16:15:05 -06005125 int wait_type, stub_unlock_result, stub_cancel_result;
David Teigland13ef1112012-04-23 12:18:18 -05005126 int dir_nodeid;
David Teiglande7fd4172006-01-18 09:30:29 +00005127
Markus Elfring102e67d2017-05-06 08:48:29 +02005128 ms_stub = kmalloc(sizeof(*ms_stub), GFP_KERNEL);
Markus Elfring0d37eca2017-05-06 08:55:43 +02005129 if (!ms_stub)
David Teigland2a7ce0e2011-04-04 15:19:59 -05005130 return;
David Teigland2a7ce0e2011-04-04 15:19:59 -05005131
David Teigland90135922006-01-20 08:47:07 +00005132 mutex_lock(&ls->ls_waiters_mutex);
David Teiglande7fd4172006-01-18 09:30:29 +00005133
5134 list_for_each_entry_safe(lkb, safe, &ls->ls_waiters, lkb_wait_reply) {
David Teigland2a7ce0e2011-04-04 15:19:59 -05005135
David Teigland13ef1112012-04-23 12:18:18 -05005136 dir_nodeid = dlm_dir_nodeid(lkb->lkb_resource);
5137
David Teigland2a7ce0e2011-04-04 15:19:59 -05005138 /* exclude debug messages about unlocks because there can be so
5139 many and they aren't very interesting */
5140
5141 if (lkb->lkb_wait_type != DLM_MSG_UNLOCK) {
David Teigland13ef1112012-04-23 12:18:18 -05005142 log_debug(ls, "waiter %x remote %x msg %d r_nodeid %d "
5143 "lkb_nodeid %d wait_nodeid %d dir_nodeid %d",
5144 lkb->lkb_id,
5145 lkb->lkb_remid,
5146 lkb->lkb_wait_type,
5147 lkb->lkb_resource->res_nodeid,
5148 lkb->lkb_nodeid,
5149 lkb->lkb_wait_nodeid,
5150 dir_nodeid);
David Teigland2a7ce0e2011-04-04 15:19:59 -05005151 }
David Teiglande7fd4172006-01-18 09:30:29 +00005152
5153 /* all outstanding lookups, regardless of destination will be
5154 resent after recovery is done */
5155
5156 if (lkb->lkb_wait_type == DLM_MSG_LOOKUP) {
5157 lkb->lkb_flags |= DLM_IFL_RESEND;
5158 continue;
5159 }
5160
David Teigland13ef1112012-04-23 12:18:18 -05005161 if (!waiter_needs_recovery(ls, lkb, dir_nodeid))
David Teiglande7fd4172006-01-18 09:30:29 +00005162 continue;
5163
David Teigland601342c2008-01-07 16:15:05 -06005164 wait_type = lkb->lkb_wait_type;
5165 stub_unlock_result = -DLM_EUNLOCK;
5166 stub_cancel_result = -DLM_ECANCEL;
5167
5168 /* Main reply may have been received leaving a zero wait_type,
5169 but a reply for the overlapping op may not have been
5170 received. In that case we need to fake the appropriate
5171 reply for the overlap op. */
5172
5173 if (!wait_type) {
5174 if (is_overlap_cancel(lkb)) {
5175 wait_type = DLM_MSG_CANCEL;
5176 if (lkb->lkb_grmode == DLM_LOCK_IV)
5177 stub_cancel_result = 0;
5178 }
5179 if (is_overlap_unlock(lkb)) {
5180 wait_type = DLM_MSG_UNLOCK;
5181 if (lkb->lkb_grmode == DLM_LOCK_IV)
5182 stub_unlock_result = -ENOENT;
5183 }
5184
5185 log_debug(ls, "rwpre overlap %x %x %d %d %d",
5186 lkb->lkb_id, lkb->lkb_flags, wait_type,
5187 stub_cancel_result, stub_unlock_result);
5188 }
5189
5190 switch (wait_type) {
David Teiglande7fd4172006-01-18 09:30:29 +00005191
5192 case DLM_MSG_REQUEST:
5193 lkb->lkb_flags |= DLM_IFL_RESEND;
5194 break;
5195
5196 case DLM_MSG_CONVERT:
David Teigland2a7ce0e2011-04-04 15:19:59 -05005197 recover_convert_waiter(ls, lkb, ms_stub);
David Teiglande7fd4172006-01-18 09:30:29 +00005198 break;
5199
5200 case DLM_MSG_UNLOCK:
5201 hold_lkb(lkb);
David Teigland2a7ce0e2011-04-04 15:19:59 -05005202 memset(ms_stub, 0, sizeof(struct dlm_message));
5203 ms_stub->m_flags = DLM_IFL_STUB_MS;
5204 ms_stub->m_type = DLM_MSG_UNLOCK_REPLY;
5205 ms_stub->m_result = stub_unlock_result;
5206 ms_stub->m_header.h_nodeid = lkb->lkb_nodeid;
5207 _receive_unlock_reply(lkb, ms_stub);
David Teiglandb3f58d82006-02-28 11:16:37 -05005208 dlm_put_lkb(lkb);
David Teiglande7fd4172006-01-18 09:30:29 +00005209 break;
5210
5211 case DLM_MSG_CANCEL:
5212 hold_lkb(lkb);
David Teigland2a7ce0e2011-04-04 15:19:59 -05005213 memset(ms_stub, 0, sizeof(struct dlm_message));
5214 ms_stub->m_flags = DLM_IFL_STUB_MS;
5215 ms_stub->m_type = DLM_MSG_CANCEL_REPLY;
5216 ms_stub->m_result = stub_cancel_result;
5217 ms_stub->m_header.h_nodeid = lkb->lkb_nodeid;
5218 _receive_cancel_reply(lkb, ms_stub);
David Teiglandb3f58d82006-02-28 11:16:37 -05005219 dlm_put_lkb(lkb);
David Teiglande7fd4172006-01-18 09:30:29 +00005220 break;
5221
5222 default:
David Teigland601342c2008-01-07 16:15:05 -06005223 log_error(ls, "invalid lkb wait_type %d %d",
5224 lkb->lkb_wait_type, wait_type);
David Teiglande7fd4172006-01-18 09:30:29 +00005225 }
David Teigland81456802006-07-25 14:05:09 -05005226 schedule();
David Teiglande7fd4172006-01-18 09:30:29 +00005227 }
David Teigland90135922006-01-20 08:47:07 +00005228 mutex_unlock(&ls->ls_waiters_mutex);
David Teigland2a7ce0e2011-04-04 15:19:59 -05005229 kfree(ms_stub);
David Teiglande7fd4172006-01-18 09:30:29 +00005230}
5231
David Teiglandef0c2bb2007-03-28 09:56:46 -05005232static struct dlm_lkb *find_resend_waiter(struct dlm_ls *ls)
David Teiglande7fd4172006-01-18 09:30:29 +00005233{
5234 struct dlm_lkb *lkb;
David Teiglandef0c2bb2007-03-28 09:56:46 -05005235 int found = 0;
David Teiglande7fd4172006-01-18 09:30:29 +00005236
David Teigland90135922006-01-20 08:47:07 +00005237 mutex_lock(&ls->ls_waiters_mutex);
David Teiglande7fd4172006-01-18 09:30:29 +00005238 list_for_each_entry(lkb, &ls->ls_waiters, lkb_wait_reply) {
5239 if (lkb->lkb_flags & DLM_IFL_RESEND) {
David Teiglandef0c2bb2007-03-28 09:56:46 -05005240 hold_lkb(lkb);
5241 found = 1;
David Teiglande7fd4172006-01-18 09:30:29 +00005242 break;
5243 }
5244 }
David Teigland90135922006-01-20 08:47:07 +00005245 mutex_unlock(&ls->ls_waiters_mutex);
David Teiglande7fd4172006-01-18 09:30:29 +00005246
David Teiglandef0c2bb2007-03-28 09:56:46 -05005247 if (!found)
David Teiglande7fd4172006-01-18 09:30:29 +00005248 lkb = NULL;
David Teiglandef0c2bb2007-03-28 09:56:46 -05005249 return lkb;
David Teiglande7fd4172006-01-18 09:30:29 +00005250}
5251
5252/* Deal with lookups and lkb's marked RESEND from _pre. We may now be the
5253 master or dir-node for r. Processing the lkb may result in it being placed
5254 back on waiters. */
5255
David Teiglandef0c2bb2007-03-28 09:56:46 -05005256/* We do this after normal locking has been enabled and any saved messages
5257 (in requestqueue) have been processed. We should be confident that at
5258 this point we won't get or process a reply to any of these waiting
5259 operations. But, new ops may be coming in on the rsbs/locks here from
5260 userspace or remotely. */
5261
5262/* there may have been an overlap unlock/cancel prior to recovery or after
5263 recovery. if before, the lkb may still have a pos wait_count; if after, the
5264 overlap flag would just have been set and nothing new sent. we can be
5265 confident here than any replies to either the initial op or overlap ops
5266 prior to recovery have been received. */
5267
David Teiglande7fd4172006-01-18 09:30:29 +00005268int dlm_recover_waiters_post(struct dlm_ls *ls)
5269{
5270 struct dlm_lkb *lkb;
5271 struct dlm_rsb *r;
David Teiglandef0c2bb2007-03-28 09:56:46 -05005272 int error = 0, mstype, err, oc, ou;
David Teiglande7fd4172006-01-18 09:30:29 +00005273
5274 while (1) {
5275 if (dlm_locking_stopped(ls)) {
5276 log_debug(ls, "recover_waiters_post aborted");
5277 error = -EINTR;
5278 break;
5279 }
5280
David Teiglandef0c2bb2007-03-28 09:56:46 -05005281 lkb = find_resend_waiter(ls);
5282 if (!lkb)
David Teiglande7fd4172006-01-18 09:30:29 +00005283 break;
5284
5285 r = lkb->lkb_resource;
David Teiglandef0c2bb2007-03-28 09:56:46 -05005286 hold_rsb(r);
5287 lock_rsb(r);
5288
5289 mstype = lkb->lkb_wait_type;
5290 oc = is_overlap_cancel(lkb);
5291 ou = is_overlap_unlock(lkb);
5292 err = 0;
David Teiglande7fd4172006-01-18 09:30:29 +00005293
David Teigland13ef1112012-04-23 12:18:18 -05005294 log_debug(ls, "waiter %x remote %x msg %d r_nodeid %d "
5295 "lkb_nodeid %d wait_nodeid %d dir_nodeid %d "
5296 "overlap %d %d", lkb->lkb_id, lkb->lkb_remid, mstype,
5297 r->res_nodeid, lkb->lkb_nodeid, lkb->lkb_wait_nodeid,
5298 dlm_dir_nodeid(r), oc, ou);
David Teiglande7fd4172006-01-18 09:30:29 +00005299
David Teiglandef0c2bb2007-03-28 09:56:46 -05005300 /* At this point we assume that we won't get a reply to any
5301 previous op or overlap op on this lock. First, do a big
5302 remove_from_waiters() for all previous ops. */
David Teiglande7fd4172006-01-18 09:30:29 +00005303
David Teiglandef0c2bb2007-03-28 09:56:46 -05005304 lkb->lkb_flags &= ~DLM_IFL_RESEND;
5305 lkb->lkb_flags &= ~DLM_IFL_OVERLAP_UNLOCK;
5306 lkb->lkb_flags &= ~DLM_IFL_OVERLAP_CANCEL;
5307 lkb->lkb_wait_type = 0;
5308 lkb->lkb_wait_count = 0;
5309 mutex_lock(&ls->ls_waiters_mutex);
5310 list_del_init(&lkb->lkb_wait_reply);
5311 mutex_unlock(&ls->ls_waiters_mutex);
5312 unhold_lkb(lkb); /* for waiters list */
David Teiglande7fd4172006-01-18 09:30:29 +00005313
David Teiglandef0c2bb2007-03-28 09:56:46 -05005314 if (oc || ou) {
5315 /* do an unlock or cancel instead of resending */
5316 switch (mstype) {
5317 case DLM_MSG_LOOKUP:
5318 case DLM_MSG_REQUEST:
5319 queue_cast(r, lkb, ou ? -DLM_EUNLOCK :
5320 -DLM_ECANCEL);
5321 unhold_lkb(lkb); /* undoes create_lkb() */
5322 break;
5323 case DLM_MSG_CONVERT:
5324 if (oc) {
5325 queue_cast(r, lkb, -DLM_ECANCEL);
5326 } else {
5327 lkb->lkb_exflags |= DLM_LKF_FORCEUNLOCK;
5328 _unlock_lock(r, lkb);
5329 }
5330 break;
5331 default:
5332 err = 1;
5333 }
5334 } else {
5335 switch (mstype) {
5336 case DLM_MSG_LOOKUP:
5337 case DLM_MSG_REQUEST:
5338 _request_lock(r, lkb);
5339 if (is_master(r))
5340 confirm_master(r, 0);
5341 break;
5342 case DLM_MSG_CONVERT:
5343 _convert_lock(r, lkb);
5344 break;
5345 default:
5346 err = 1;
5347 }
David Teiglande7fd4172006-01-18 09:30:29 +00005348 }
David Teiglandef0c2bb2007-03-28 09:56:46 -05005349
David Teigland13ef1112012-04-23 12:18:18 -05005350 if (err) {
5351 log_error(ls, "waiter %x msg %d r_nodeid %d "
5352 "dir_nodeid %d overlap %d %d",
5353 lkb->lkb_id, mstype, r->res_nodeid,
5354 dlm_dir_nodeid(r), oc, ou);
5355 }
David Teiglandef0c2bb2007-03-28 09:56:46 -05005356 unlock_rsb(r);
5357 put_rsb(r);
5358 dlm_put_lkb(lkb);
David Teiglande7fd4172006-01-18 09:30:29 +00005359 }
5360
5361 return error;
5362}
5363
David Teigland48756472012-04-26 15:54:29 -05005364static void purge_mstcpy_list(struct dlm_ls *ls, struct dlm_rsb *r,
5365 struct list_head *list)
David Teiglande7fd4172006-01-18 09:30:29 +00005366{
David Teiglande7fd4172006-01-18 09:30:29 +00005367 struct dlm_lkb *lkb, *safe;
5368
David Teigland48756472012-04-26 15:54:29 -05005369 list_for_each_entry_safe(lkb, safe, list, lkb_statequeue) {
5370 if (!is_master_copy(lkb))
5371 continue;
5372
5373 /* don't purge lkbs we've added in recover_master_copy for
5374 the current recovery seq */
5375
5376 if (lkb->lkb_recover_seq == ls->ls_recover_seq)
5377 continue;
5378
5379 del_lkb(r, lkb);
5380
5381 /* this put should free the lkb */
5382 if (!dlm_put_lkb(lkb))
5383 log_error(ls, "purged mstcpy lkb not released");
David Teiglande7fd4172006-01-18 09:30:29 +00005384 }
5385}
5386
David Teiglande7fd4172006-01-18 09:30:29 +00005387void dlm_purge_mstcpy_locks(struct dlm_rsb *r)
5388{
David Teigland48756472012-04-26 15:54:29 -05005389 struct dlm_ls *ls = r->res_ls;
5390
5391 purge_mstcpy_list(ls, r, &r->res_grantqueue);
5392 purge_mstcpy_list(ls, r, &r->res_convertqueue);
5393 purge_mstcpy_list(ls, r, &r->res_waitqueue);
5394}
5395
5396static void purge_dead_list(struct dlm_ls *ls, struct dlm_rsb *r,
5397 struct list_head *list,
5398 int nodeid_gone, unsigned int *count)
5399{
5400 struct dlm_lkb *lkb, *safe;
5401
5402 list_for_each_entry_safe(lkb, safe, list, lkb_statequeue) {
5403 if (!is_master_copy(lkb))
5404 continue;
5405
5406 if ((lkb->lkb_nodeid == nodeid_gone) ||
5407 dlm_is_removed(ls, lkb->lkb_nodeid)) {
5408
David Teiglandda8c6662012-11-15 15:01:51 -06005409 /* tell recover_lvb to invalidate the lvb
5410 because a node holding EX/PW failed */
5411 if ((lkb->lkb_exflags & DLM_LKF_VALBLK) &&
5412 (lkb->lkb_grmode >= DLM_LOCK_PW)) {
5413 rsb_set_flag(r, RSB_RECOVER_LVB_INVAL);
5414 }
5415
David Teigland48756472012-04-26 15:54:29 -05005416 del_lkb(r, lkb);
5417
5418 /* this put should free the lkb */
5419 if (!dlm_put_lkb(lkb))
5420 log_error(ls, "purged dead lkb not released");
5421
5422 rsb_set_flag(r, RSB_RECOVER_GRANT);
5423
5424 (*count)++;
5425 }
5426 }
David Teiglande7fd4172006-01-18 09:30:29 +00005427}
5428
5429/* Get rid of locks held by nodes that are gone. */
5430
David Teigland48756472012-04-26 15:54:29 -05005431void dlm_recover_purge(struct dlm_ls *ls)
David Teiglande7fd4172006-01-18 09:30:29 +00005432{
5433 struct dlm_rsb *r;
David Teigland48756472012-04-26 15:54:29 -05005434 struct dlm_member *memb;
5435 int nodes_count = 0;
5436 int nodeid_gone = 0;
5437 unsigned int lkb_count = 0;
David Teiglande7fd4172006-01-18 09:30:29 +00005438
David Teigland48756472012-04-26 15:54:29 -05005439 /* cache one removed nodeid to optimize the common
5440 case of a single node removed */
5441
5442 list_for_each_entry(memb, &ls->ls_nodes_gone, list) {
5443 nodes_count++;
5444 nodeid_gone = memb->nodeid;
5445 }
5446
5447 if (!nodes_count)
5448 return;
David Teiglande7fd4172006-01-18 09:30:29 +00005449
5450 down_write(&ls->ls_root_sem);
5451 list_for_each_entry(r, &ls->ls_root_list, res_root_list) {
5452 hold_rsb(r);
5453 lock_rsb(r);
David Teigland48756472012-04-26 15:54:29 -05005454 if (is_master(r)) {
5455 purge_dead_list(ls, r, &r->res_grantqueue,
5456 nodeid_gone, &lkb_count);
5457 purge_dead_list(ls, r, &r->res_convertqueue,
5458 nodeid_gone, &lkb_count);
5459 purge_dead_list(ls, r, &r->res_waitqueue,
5460 nodeid_gone, &lkb_count);
5461 }
David Teiglande7fd4172006-01-18 09:30:29 +00005462 unlock_rsb(r);
5463 unhold_rsb(r);
David Teigland48756472012-04-26 15:54:29 -05005464 cond_resched();
David Teiglande7fd4172006-01-18 09:30:29 +00005465 }
5466 up_write(&ls->ls_root_sem);
5467
David Teigland48756472012-04-26 15:54:29 -05005468 if (lkb_count)
David Teigland075f0172014-02-14 11:54:44 -06005469 log_rinfo(ls, "dlm_recover_purge %u locks for %u nodes",
David Teigland48756472012-04-26 15:54:29 -05005470 lkb_count, nodes_count);
David Teiglande7fd4172006-01-18 09:30:29 +00005471}
5472
David Teigland48756472012-04-26 15:54:29 -05005473static struct dlm_rsb *find_grant_rsb(struct dlm_ls *ls, int bucket)
David Teigland97a35d12006-05-02 13:34:03 -04005474{
Bob Peterson9beb3bf2011-10-26 15:24:55 -05005475 struct rb_node *n;
David Teigland48756472012-04-26 15:54:29 -05005476 struct dlm_rsb *r;
David Teigland97a35d12006-05-02 13:34:03 -04005477
David Teiglandc7be7612009-01-07 16:50:41 -06005478 spin_lock(&ls->ls_rsbtbl[bucket].lock);
Bob Peterson9beb3bf2011-10-26 15:24:55 -05005479 for (n = rb_first(&ls->ls_rsbtbl[bucket].keep); n; n = rb_next(n)) {
5480 r = rb_entry(n, struct dlm_rsb, res_hashnode);
David Teigland48756472012-04-26 15:54:29 -05005481
5482 if (!rsb_flag(r, RSB_RECOVER_GRANT))
5483 continue;
David Teiglandc503a622012-06-05 15:55:19 -05005484 if (!is_master(r)) {
5485 rsb_clear_flag(r, RSB_RECOVER_GRANT);
David Teigland97a35d12006-05-02 13:34:03 -04005486 continue;
David Teiglandc503a622012-06-05 15:55:19 -05005487 }
David Teigland97a35d12006-05-02 13:34:03 -04005488 hold_rsb(r);
David Teigland48756472012-04-26 15:54:29 -05005489 spin_unlock(&ls->ls_rsbtbl[bucket].lock);
5490 return r;
David Teigland97a35d12006-05-02 13:34:03 -04005491 }
David Teiglandc7be7612009-01-07 16:50:41 -06005492 spin_unlock(&ls->ls_rsbtbl[bucket].lock);
David Teigland48756472012-04-26 15:54:29 -05005493 return NULL;
David Teigland97a35d12006-05-02 13:34:03 -04005494}
5495
David Teigland48756472012-04-26 15:54:29 -05005496/*
5497 * Attempt to grant locks on resources that we are the master of.
5498 * Locks may have become grantable during recovery because locks
5499 * from departed nodes have been purged (or not rebuilt), allowing
5500 * previously blocked locks to now be granted. The subset of rsb's
5501 * we are interested in are those with lkb's on either the convert or
5502 * waiting queues.
5503 *
5504 * Simplest would be to go through each master rsb and check for non-empty
5505 * convert or waiting queues, and attempt to grant on those rsbs.
5506 * Checking the queues requires lock_rsb, though, for which we'd need
5507 * to release the rsbtbl lock. This would make iterating through all
5508 * rsb's very inefficient. So, we rely on earlier recovery routines
5509 * to set RECOVER_GRANT on any rsb's that we should attempt to grant
5510 * locks for.
5511 */
5512
5513void dlm_recover_grant(struct dlm_ls *ls)
David Teiglande7fd4172006-01-18 09:30:29 +00005514{
5515 struct dlm_rsb *r;
David Teigland2b4e9262006-07-25 13:59:48 -05005516 int bucket = 0;
David Teigland48756472012-04-26 15:54:29 -05005517 unsigned int count = 0;
5518 unsigned int rsb_count = 0;
5519 unsigned int lkb_count = 0;
David Teiglande7fd4172006-01-18 09:30:29 +00005520
David Teigland2b4e9262006-07-25 13:59:48 -05005521 while (1) {
David Teigland48756472012-04-26 15:54:29 -05005522 r = find_grant_rsb(ls, bucket);
David Teigland2b4e9262006-07-25 13:59:48 -05005523 if (!r) {
5524 if (bucket == ls->ls_rsbtbl_size - 1)
5525 break;
5526 bucket++;
David Teigland97a35d12006-05-02 13:34:03 -04005527 continue;
David Teigland2b4e9262006-07-25 13:59:48 -05005528 }
David Teigland48756472012-04-26 15:54:29 -05005529 rsb_count++;
5530 count = 0;
David Teigland97a35d12006-05-02 13:34:03 -04005531 lock_rsb(r);
David Teiglandc503a622012-06-05 15:55:19 -05005532 /* the RECOVER_GRANT flag is checked in the grant path */
David Teigland48756472012-04-26 15:54:29 -05005533 grant_pending_locks(r, &count);
David Teiglandc503a622012-06-05 15:55:19 -05005534 rsb_clear_flag(r, RSB_RECOVER_GRANT);
David Teigland48756472012-04-26 15:54:29 -05005535 lkb_count += count;
5536 confirm_master(r, 0);
David Teigland97a35d12006-05-02 13:34:03 -04005537 unlock_rsb(r);
5538 put_rsb(r);
David Teigland48756472012-04-26 15:54:29 -05005539 cond_resched();
David Teiglande7fd4172006-01-18 09:30:29 +00005540 }
David Teigland48756472012-04-26 15:54:29 -05005541
5542 if (lkb_count)
David Teigland075f0172014-02-14 11:54:44 -06005543 log_rinfo(ls, "dlm_recover_grant %u locks on %u resources",
David Teigland48756472012-04-26 15:54:29 -05005544 lkb_count, rsb_count);
David Teiglande7fd4172006-01-18 09:30:29 +00005545}
5546
5547static struct dlm_lkb *search_remid_list(struct list_head *head, int nodeid,
5548 uint32_t remid)
5549{
5550 struct dlm_lkb *lkb;
5551
5552 list_for_each_entry(lkb, head, lkb_statequeue) {
5553 if (lkb->lkb_nodeid == nodeid && lkb->lkb_remid == remid)
5554 return lkb;
5555 }
5556 return NULL;
5557}
5558
5559static struct dlm_lkb *search_remid(struct dlm_rsb *r, int nodeid,
5560 uint32_t remid)
5561{
5562 struct dlm_lkb *lkb;
5563
5564 lkb = search_remid_list(&r->res_grantqueue, nodeid, remid);
5565 if (lkb)
5566 return lkb;
5567 lkb = search_remid_list(&r->res_convertqueue, nodeid, remid);
5568 if (lkb)
5569 return lkb;
5570 lkb = search_remid_list(&r->res_waitqueue, nodeid, remid);
5571 if (lkb)
5572 return lkb;
5573 return NULL;
5574}
5575
Al Viroae773d02008-01-25 19:55:09 -05005576/* needs at least dlm_rcom + rcom_lock */
David Teiglande7fd4172006-01-18 09:30:29 +00005577static int receive_rcom_lock_args(struct dlm_ls *ls, struct dlm_lkb *lkb,
5578 struct dlm_rsb *r, struct dlm_rcom *rc)
5579{
5580 struct rcom_lock *rl = (struct rcom_lock *) rc->rc_buf;
David Teiglande7fd4172006-01-18 09:30:29 +00005581
5582 lkb->lkb_nodeid = rc->rc_header.h_nodeid;
Al Viro163a1852008-01-25 02:08:26 -05005583 lkb->lkb_ownpid = le32_to_cpu(rl->rl_ownpid);
5584 lkb->lkb_remid = le32_to_cpu(rl->rl_lkid);
5585 lkb->lkb_exflags = le32_to_cpu(rl->rl_exflags);
5586 lkb->lkb_flags = le32_to_cpu(rl->rl_flags) & 0x0000FFFF;
David Teiglande7fd4172006-01-18 09:30:29 +00005587 lkb->lkb_flags |= DLM_IFL_MSTCPY;
Al Viro163a1852008-01-25 02:08:26 -05005588 lkb->lkb_lvbseq = le32_to_cpu(rl->rl_lvbseq);
David Teiglande7fd4172006-01-18 09:30:29 +00005589 lkb->lkb_rqmode = rl->rl_rqmode;
5590 lkb->lkb_grmode = rl->rl_grmode;
5591 /* don't set lkb_status because add_lkb wants to itself */
5592
David Teigland8304d6f2011-02-21 14:58:21 -06005593 lkb->lkb_bastfn = (rl->rl_asts & DLM_CB_BAST) ? &fake_bastfn : NULL;
5594 lkb->lkb_astfn = (rl->rl_asts & DLM_CB_CAST) ? &fake_astfn : NULL;
David Teiglande7fd4172006-01-18 09:30:29 +00005595
David Teiglande7fd4172006-01-18 09:30:29 +00005596 if (lkb->lkb_exflags & DLM_LKF_VALBLK) {
Al Viroa5dd0632008-01-25 20:22:22 -05005597 int lvblen = rc->rc_header.h_length - sizeof(struct dlm_rcom) -
5598 sizeof(struct rcom_lock);
5599 if (lvblen > ls->ls_lvblen)
5600 return -EINVAL;
David Teigland52bda2b2007-11-07 09:06:49 -06005601 lkb->lkb_lvbptr = dlm_allocate_lvb(ls);
David Teiglande7fd4172006-01-18 09:30:29 +00005602 if (!lkb->lkb_lvbptr)
5603 return -ENOMEM;
David Teiglande7fd4172006-01-18 09:30:29 +00005604 memcpy(lkb->lkb_lvbptr, rl->rl_lvb, lvblen);
5605 }
5606
5607 /* Conversions between PR and CW (middle modes) need special handling.
5608 The real granted mode of these converting locks cannot be determined
5609 until all locks have been rebuilt on the rsb (recover_conversion) */
5610
Al Viro163a1852008-01-25 02:08:26 -05005611 if (rl->rl_wait_type == cpu_to_le16(DLM_MSG_CONVERT) &&
5612 middle_conversion(lkb)) {
David Teiglande7fd4172006-01-18 09:30:29 +00005613 rl->rl_status = DLM_LKSTS_CONVERT;
5614 lkb->lkb_grmode = DLM_LOCK_IV;
5615 rsb_set_flag(r, RSB_RECOVER_CONVERT);
5616 }
5617
5618 return 0;
5619}
5620
5621/* This lkb may have been recovered in a previous aborted recovery so we need
5622 to check if the rsb already has an lkb with the given remote nodeid/lkid.
5623 If so we just send back a standard reply. If not, we create a new lkb with
5624 the given values and send back our lkid. We send back our lkid by sending
5625 back the rcom_lock struct we got but with the remid field filled in. */
5626
Al Viroae773d02008-01-25 19:55:09 -05005627/* needs at least dlm_rcom + rcom_lock */
David Teiglande7fd4172006-01-18 09:30:29 +00005628int dlm_recover_master_copy(struct dlm_ls *ls, struct dlm_rcom *rc)
5629{
5630 struct rcom_lock *rl = (struct rcom_lock *) rc->rc_buf;
5631 struct dlm_rsb *r;
5632 struct dlm_lkb *lkb;
David Teigland6d40c4a2012-04-23 16:36:01 -05005633 uint32_t remid = 0;
David Teiglandc04fecb2012-05-10 10:18:07 -05005634 int from_nodeid = rc->rc_header.h_nodeid;
David Teiglande7fd4172006-01-18 09:30:29 +00005635 int error;
5636
5637 if (rl->rl_parent_lkid) {
5638 error = -EOPNOTSUPP;
5639 goto out;
5640 }
5641
David Teigland6d40c4a2012-04-23 16:36:01 -05005642 remid = le32_to_cpu(rl->rl_lkid);
5643
David Teigland48756472012-04-26 15:54:29 -05005644 /* In general we expect the rsb returned to be R_MASTER, but we don't
5645 have to require it. Recovery of masters on one node can overlap
5646 recovery of locks on another node, so one node can send us MSTCPY
5647 locks before we've made ourselves master of this rsb. We can still
5648 add new MSTCPY locks that we receive here without any harm; when
5649 we make ourselves master, dlm_recover_masters() won't touch the
5650 MSTCPY locks we've received early. */
5651
David Teiglandc04fecb2012-05-10 10:18:07 -05005652 error = find_rsb(ls, rl->rl_name, le16_to_cpu(rl->rl_namelen),
5653 from_nodeid, R_RECEIVE_RECOVER, &r);
David Teiglande7fd4172006-01-18 09:30:29 +00005654 if (error)
5655 goto out;
5656
5657 lock_rsb(r);
5658
David Teiglandc04fecb2012-05-10 10:18:07 -05005659 if (dlm_no_directory(ls) && (dlm_dir_nodeid(r) != dlm_our_nodeid())) {
5660 log_error(ls, "dlm_recover_master_copy remote %d %x not dir",
5661 from_nodeid, remid);
5662 error = -EBADR;
5663 goto out_unlock;
5664 }
5665
5666 lkb = search_remid(r, from_nodeid, remid);
David Teiglande7fd4172006-01-18 09:30:29 +00005667 if (lkb) {
5668 error = -EEXIST;
5669 goto out_remid;
5670 }
5671
5672 error = create_lkb(ls, &lkb);
5673 if (error)
5674 goto out_unlock;
5675
5676 error = receive_rcom_lock_args(ls, lkb, r, rc);
5677 if (error) {
David Teiglandb3f58d82006-02-28 11:16:37 -05005678 __put_lkb(ls, lkb);
David Teiglande7fd4172006-01-18 09:30:29 +00005679 goto out_unlock;
5680 }
5681
5682 attach_lkb(r, lkb);
5683 add_lkb(r, lkb, rl->rl_status);
5684 error = 0;
David Teigland48756472012-04-26 15:54:29 -05005685 ls->ls_recover_locks_in++;
5686
5687 if (!list_empty(&r->res_waitqueue) || !list_empty(&r->res_convertqueue))
5688 rsb_set_flag(r, RSB_RECOVER_GRANT);
David Teiglande7fd4172006-01-18 09:30:29 +00005689
5690 out_remid:
5691 /* this is the new value returned to the lock holder for
5692 saving in its process-copy lkb */
Al Viro163a1852008-01-25 02:08:26 -05005693 rl->rl_remid = cpu_to_le32(lkb->lkb_id);
David Teiglande7fd4172006-01-18 09:30:29 +00005694
David Teigland48756472012-04-26 15:54:29 -05005695 lkb->lkb_recover_seq = ls->ls_recover_seq;
5696
David Teiglande7fd4172006-01-18 09:30:29 +00005697 out_unlock:
5698 unlock_rsb(r);
5699 put_rsb(r);
5700 out:
David Teigland6d40c4a2012-04-23 16:36:01 -05005701 if (error && error != -EEXIST)
David Teigland075f0172014-02-14 11:54:44 -06005702 log_rinfo(ls, "dlm_recover_master_copy remote %d %x error %d",
David Teiglandc04fecb2012-05-10 10:18:07 -05005703 from_nodeid, remid, error);
Al Viro163a1852008-01-25 02:08:26 -05005704 rl->rl_result = cpu_to_le32(error);
David Teiglande7fd4172006-01-18 09:30:29 +00005705 return error;
5706}
5707
Al Viroae773d02008-01-25 19:55:09 -05005708/* needs at least dlm_rcom + rcom_lock */
David Teiglande7fd4172006-01-18 09:30:29 +00005709int dlm_recover_process_copy(struct dlm_ls *ls, struct dlm_rcom *rc)
5710{
5711 struct rcom_lock *rl = (struct rcom_lock *) rc->rc_buf;
5712 struct dlm_rsb *r;
5713 struct dlm_lkb *lkb;
David Teigland6d40c4a2012-04-23 16:36:01 -05005714 uint32_t lkid, remid;
5715 int error, result;
David Teiglande7fd4172006-01-18 09:30:29 +00005716
David Teigland6d40c4a2012-04-23 16:36:01 -05005717 lkid = le32_to_cpu(rl->rl_lkid);
5718 remid = le32_to_cpu(rl->rl_remid);
5719 result = le32_to_cpu(rl->rl_result);
5720
5721 error = find_lkb(ls, lkid, &lkb);
David Teiglande7fd4172006-01-18 09:30:29 +00005722 if (error) {
David Teigland6d40c4a2012-04-23 16:36:01 -05005723 log_error(ls, "dlm_recover_process_copy no %x remote %d %x %d",
5724 lkid, rc->rc_header.h_nodeid, remid, result);
David Teiglande7fd4172006-01-18 09:30:29 +00005725 return error;
5726 }
5727
David Teiglande7fd4172006-01-18 09:30:29 +00005728 r = lkb->lkb_resource;
5729 hold_rsb(r);
5730 lock_rsb(r);
5731
David Teigland48756472012-04-26 15:54:29 -05005732 if (!is_process_copy(lkb)) {
5733 log_error(ls, "dlm_recover_process_copy bad %x remote %d %x %d",
5734 lkid, rc->rc_header.h_nodeid, remid, result);
5735 dlm_dump_rsb(r);
5736 unlock_rsb(r);
5737 put_rsb(r);
5738 dlm_put_lkb(lkb);
5739 return -EINVAL;
5740 }
5741
David Teigland6d40c4a2012-04-23 16:36:01 -05005742 switch (result) {
David Teiglanddc200a82006-12-13 10:36:37 -06005743 case -EBADR:
5744 /* There's a chance the new master received our lock before
5745 dlm_recover_master_reply(), this wouldn't happen if we did
5746 a barrier between recover_masters and recover_locks. */
David Teigland6d40c4a2012-04-23 16:36:01 -05005747
5748 log_debug(ls, "dlm_recover_process_copy %x remote %d %x %d",
5749 lkid, rc->rc_header.h_nodeid, remid, result);
5750
David Teiglanddc200a82006-12-13 10:36:37 -06005751 dlm_send_rcom_lock(r, lkb);
5752 goto out;
David Teiglande7fd4172006-01-18 09:30:29 +00005753 case -EEXIST:
David Teiglande7fd4172006-01-18 09:30:29 +00005754 case 0:
David Teigland6d40c4a2012-04-23 16:36:01 -05005755 lkb->lkb_remid = remid;
David Teiglande7fd4172006-01-18 09:30:29 +00005756 break;
5757 default:
David Teigland6d40c4a2012-04-23 16:36:01 -05005758 log_error(ls, "dlm_recover_process_copy %x remote %d %x %d unk",
5759 lkid, rc->rc_header.h_nodeid, remid, result);
David Teiglande7fd4172006-01-18 09:30:29 +00005760 }
5761
5762 /* an ack for dlm_recover_locks() which waits for replies from
5763 all the locks it sends to new masters */
5764 dlm_recovered_lock(r);
David Teiglanddc200a82006-12-13 10:36:37 -06005765 out:
David Teiglande7fd4172006-01-18 09:30:29 +00005766 unlock_rsb(r);
5767 put_rsb(r);
David Teiglandb3f58d82006-02-28 11:16:37 -05005768 dlm_put_lkb(lkb);
David Teiglande7fd4172006-01-18 09:30:29 +00005769
5770 return 0;
5771}
5772
David Teigland597d0ca2006-07-12 16:44:04 -05005773int dlm_user_request(struct dlm_ls *ls, struct dlm_user_args *ua,
5774 int mode, uint32_t flags, void *name, unsigned int namelen,
David Teiglandd7db9232007-05-18 09:00:32 -05005775 unsigned long timeout_cs)
David Teigland597d0ca2006-07-12 16:44:04 -05005776{
5777 struct dlm_lkb *lkb;
5778 struct dlm_args args;
5779 int error;
5780
David Teigland85e86ed2007-05-18 08:58:15 -05005781 dlm_lock_recovery(ls);
David Teigland597d0ca2006-07-12 16:44:04 -05005782
5783 error = create_lkb(ls, &lkb);
5784 if (error) {
5785 kfree(ua);
5786 goto out;
5787 }
5788
5789 if (flags & DLM_LKF_VALBLK) {
David Teigland573c24c2009-11-30 16:34:43 -06005790 ua->lksb.sb_lvbptr = kzalloc(DLM_USER_LVB_LEN, GFP_NOFS);
David Teigland597d0ca2006-07-12 16:44:04 -05005791 if (!ua->lksb.sb_lvbptr) {
5792 kfree(ua);
5793 __put_lkb(ls, lkb);
5794 error = -ENOMEM;
5795 goto out;
5796 }
5797 }
David Teiglandd7db9232007-05-18 09:00:32 -05005798 error = set_lock_args(mode, &ua->lksb, flags, namelen, timeout_cs,
David Teiglande5dae542008-02-06 00:35:45 -06005799 fake_astfn, ua, fake_bastfn, &args);
David Teigland597d0ca2006-07-12 16:44:04 -05005800 if (error) {
Vasily Averind47b41a2018-11-15 13:18:56 +03005801 kfree(ua->lksb.sb_lvbptr);
5802 ua->lksb.sb_lvbptr = NULL;
5803 kfree(ua);
David Teigland597d0ca2006-07-12 16:44:04 -05005804 __put_lkb(ls, lkb);
5805 goto out;
5806 }
5807
Vasily Averind47b41a2018-11-15 13:18:56 +03005808 /* After ua is attached to lkb it will be freed by dlm_free_lkb().
5809 When DLM_IFL_USER is set, the dlm knows that this is a userspace
5810 lock and that lkb_astparam is the dlm_user_args structure. */
5811 lkb->lkb_flags |= DLM_IFL_USER;
David Teigland597d0ca2006-07-12 16:44:04 -05005812 error = request_lock(ls, lkb, name, namelen, &args);
5813
5814 switch (error) {
5815 case 0:
5816 break;
5817 case -EINPROGRESS:
5818 error = 0;
5819 break;
5820 case -EAGAIN:
5821 error = 0;
5822 /* fall through */
5823 default:
5824 __put_lkb(ls, lkb);
5825 goto out;
5826 }
5827
5828 /* add this new lkb to the per-process list of locks */
5829 spin_lock(&ua->proc->locks_spin);
David Teiglandef0c2bb2007-03-28 09:56:46 -05005830 hold_lkb(lkb);
David Teigland597d0ca2006-07-12 16:44:04 -05005831 list_add_tail(&lkb->lkb_ownqueue, &ua->proc->locks);
5832 spin_unlock(&ua->proc->locks_spin);
5833 out:
David Teigland85e86ed2007-05-18 08:58:15 -05005834 dlm_unlock_recovery(ls);
David Teigland597d0ca2006-07-12 16:44:04 -05005835 return error;
5836}
5837
5838int dlm_user_convert(struct dlm_ls *ls, struct dlm_user_args *ua_tmp,
David Teiglandd7db9232007-05-18 09:00:32 -05005839 int mode, uint32_t flags, uint32_t lkid, char *lvb_in,
5840 unsigned long timeout_cs)
David Teigland597d0ca2006-07-12 16:44:04 -05005841{
5842 struct dlm_lkb *lkb;
5843 struct dlm_args args;
5844 struct dlm_user_args *ua;
5845 int error;
5846
David Teigland85e86ed2007-05-18 08:58:15 -05005847 dlm_lock_recovery(ls);
David Teigland597d0ca2006-07-12 16:44:04 -05005848
5849 error = find_lkb(ls, lkid, &lkb);
5850 if (error)
5851 goto out;
5852
5853 /* user can change the params on its lock when it converts it, or
5854 add an lvb that didn't exist before */
5855
David Teiglandd292c0c2008-02-06 23:27:04 -06005856 ua = lkb->lkb_ua;
David Teigland597d0ca2006-07-12 16:44:04 -05005857
5858 if (flags & DLM_LKF_VALBLK && !ua->lksb.sb_lvbptr) {
David Teigland573c24c2009-11-30 16:34:43 -06005859 ua->lksb.sb_lvbptr = kzalloc(DLM_USER_LVB_LEN, GFP_NOFS);
David Teigland597d0ca2006-07-12 16:44:04 -05005860 if (!ua->lksb.sb_lvbptr) {
5861 error = -ENOMEM;
5862 goto out_put;
5863 }
5864 }
5865 if (lvb_in && ua->lksb.sb_lvbptr)
5866 memcpy(ua->lksb.sb_lvbptr, lvb_in, DLM_USER_LVB_LEN);
5867
David Teiglandd7db9232007-05-18 09:00:32 -05005868 ua->xid = ua_tmp->xid;
David Teigland597d0ca2006-07-12 16:44:04 -05005869 ua->castparam = ua_tmp->castparam;
5870 ua->castaddr = ua_tmp->castaddr;
5871 ua->bastparam = ua_tmp->bastparam;
5872 ua->bastaddr = ua_tmp->bastaddr;
Patrick Caulfield10948eb2006-08-23 09:49:31 +01005873 ua->user_lksb = ua_tmp->user_lksb;
David Teigland597d0ca2006-07-12 16:44:04 -05005874
David Teiglandd7db9232007-05-18 09:00:32 -05005875 error = set_lock_args(mode, &ua->lksb, flags, 0, timeout_cs,
David Teiglande5dae542008-02-06 00:35:45 -06005876 fake_astfn, ua, fake_bastfn, &args);
David Teigland597d0ca2006-07-12 16:44:04 -05005877 if (error)
5878 goto out_put;
5879
5880 error = convert_lock(ls, lkb, &args);
5881
David Teiglandc85d65e2007-05-18 09:01:26 -05005882 if (error == -EINPROGRESS || error == -EAGAIN || error == -EDEADLK)
David Teigland597d0ca2006-07-12 16:44:04 -05005883 error = 0;
5884 out_put:
5885 dlm_put_lkb(lkb);
5886 out:
David Teigland85e86ed2007-05-18 08:58:15 -05005887 dlm_unlock_recovery(ls);
David Teigland597d0ca2006-07-12 16:44:04 -05005888 kfree(ua_tmp);
5889 return error;
5890}
5891
David Teigland2ab4bd82014-10-17 11:05:50 -05005892/*
5893 * The caller asks for an orphan lock on a given resource with a given mode.
5894 * If a matching lock exists, it's moved to the owner's list of locks and
5895 * the lkid is returned.
5896 */
5897
5898int dlm_user_adopt_orphan(struct dlm_ls *ls, struct dlm_user_args *ua_tmp,
5899 int mode, uint32_t flags, void *name, unsigned int namelen,
5900 unsigned long timeout_cs, uint32_t *lkid)
5901{
5902 struct dlm_lkb *lkb;
5903 struct dlm_user_args *ua;
5904 int found_other_mode = 0;
5905 int found = 0;
5906 int rv = 0;
5907
5908 mutex_lock(&ls->ls_orphans_mutex);
5909 list_for_each_entry(lkb, &ls->ls_orphans, lkb_ownqueue) {
5910 if (lkb->lkb_resource->res_length != namelen)
5911 continue;
5912 if (memcmp(lkb->lkb_resource->res_name, name, namelen))
5913 continue;
5914 if (lkb->lkb_grmode != mode) {
5915 found_other_mode = 1;
5916 continue;
5917 }
5918
5919 found = 1;
5920 list_del_init(&lkb->lkb_ownqueue);
5921 lkb->lkb_flags &= ~DLM_IFL_ORPHAN;
5922 *lkid = lkb->lkb_id;
5923 break;
5924 }
5925 mutex_unlock(&ls->ls_orphans_mutex);
5926
5927 if (!found && found_other_mode) {
5928 rv = -EAGAIN;
5929 goto out;
5930 }
5931
5932 if (!found) {
5933 rv = -ENOENT;
5934 goto out;
5935 }
5936
5937 lkb->lkb_exflags = flags;
5938 lkb->lkb_ownpid = (int) current->pid;
5939
5940 ua = lkb->lkb_ua;
5941
5942 ua->proc = ua_tmp->proc;
5943 ua->xid = ua_tmp->xid;
5944 ua->castparam = ua_tmp->castparam;
5945 ua->castaddr = ua_tmp->castaddr;
5946 ua->bastparam = ua_tmp->bastparam;
5947 ua->bastaddr = ua_tmp->bastaddr;
5948 ua->user_lksb = ua_tmp->user_lksb;
5949
5950 /*
5951 * The lkb reference from the ls_orphans list was not
5952 * removed above, and is now considered the reference
5953 * for the proc locks list.
5954 */
5955
5956 spin_lock(&ua->proc->locks_spin);
5957 list_add_tail(&lkb->lkb_ownqueue, &ua->proc->locks);
5958 spin_unlock(&ua->proc->locks_spin);
5959 out:
5960 kfree(ua_tmp);
5961 return rv;
5962}
5963
David Teigland597d0ca2006-07-12 16:44:04 -05005964int dlm_user_unlock(struct dlm_ls *ls, struct dlm_user_args *ua_tmp,
5965 uint32_t flags, uint32_t lkid, char *lvb_in)
5966{
5967 struct dlm_lkb *lkb;
5968 struct dlm_args args;
5969 struct dlm_user_args *ua;
5970 int error;
5971
David Teigland85e86ed2007-05-18 08:58:15 -05005972 dlm_lock_recovery(ls);
David Teigland597d0ca2006-07-12 16:44:04 -05005973
5974 error = find_lkb(ls, lkid, &lkb);
5975 if (error)
5976 goto out;
5977
David Teiglandd292c0c2008-02-06 23:27:04 -06005978 ua = lkb->lkb_ua;
David Teigland597d0ca2006-07-12 16:44:04 -05005979
5980 if (lvb_in && ua->lksb.sb_lvbptr)
5981 memcpy(ua->lksb.sb_lvbptr, lvb_in, DLM_USER_LVB_LEN);
Patrick Caulfieldb434eda2007-10-01 15:28:42 +01005982 if (ua_tmp->castparam)
5983 ua->castparam = ua_tmp->castparam;
Patrick Caulfieldcc346d52006-08-08 10:34:40 -04005984 ua->user_lksb = ua_tmp->user_lksb;
David Teigland597d0ca2006-07-12 16:44:04 -05005985
5986 error = set_unlock_args(flags, ua, &args);
5987 if (error)
5988 goto out_put;
5989
5990 error = unlock_lock(ls, lkb, &args);
5991
5992 if (error == -DLM_EUNLOCK)
5993 error = 0;
David Teiglandef0c2bb2007-03-28 09:56:46 -05005994 /* from validate_unlock_args() */
5995 if (error == -EBUSY && (flags & DLM_LKF_FORCEUNLOCK))
5996 error = 0;
David Teigland597d0ca2006-07-12 16:44:04 -05005997 if (error)
5998 goto out_put;
5999
6000 spin_lock(&ua->proc->locks_spin);
David Teigland23e8e1a2011-04-05 13:16:24 -05006001 /* dlm_user_add_cb() may have already taken lkb off the proc list */
David Teiglanda1bc86e2007-01-15 10:34:52 -06006002 if (!list_empty(&lkb->lkb_ownqueue))
6003 list_move(&lkb->lkb_ownqueue, &ua->proc->unlocking);
David Teigland597d0ca2006-07-12 16:44:04 -05006004 spin_unlock(&ua->proc->locks_spin);
David Teigland597d0ca2006-07-12 16:44:04 -05006005 out_put:
6006 dlm_put_lkb(lkb);
6007 out:
David Teigland85e86ed2007-05-18 08:58:15 -05006008 dlm_unlock_recovery(ls);
David Teiglandef0c2bb2007-03-28 09:56:46 -05006009 kfree(ua_tmp);
David Teigland597d0ca2006-07-12 16:44:04 -05006010 return error;
6011}
6012
6013int dlm_user_cancel(struct dlm_ls *ls, struct dlm_user_args *ua_tmp,
6014 uint32_t flags, uint32_t lkid)
6015{
6016 struct dlm_lkb *lkb;
6017 struct dlm_args args;
6018 struct dlm_user_args *ua;
6019 int error;
6020
David Teigland85e86ed2007-05-18 08:58:15 -05006021 dlm_lock_recovery(ls);
David Teigland597d0ca2006-07-12 16:44:04 -05006022
6023 error = find_lkb(ls, lkid, &lkb);
6024 if (error)
6025 goto out;
6026
David Teiglandd292c0c2008-02-06 23:27:04 -06006027 ua = lkb->lkb_ua;
Patrick Caulfieldb434eda2007-10-01 15:28:42 +01006028 if (ua_tmp->castparam)
6029 ua->castparam = ua_tmp->castparam;
Patrick Caulfieldc059f702006-08-23 10:24:03 +01006030 ua->user_lksb = ua_tmp->user_lksb;
David Teigland597d0ca2006-07-12 16:44:04 -05006031
6032 error = set_unlock_args(flags, ua, &args);
6033 if (error)
6034 goto out_put;
6035
6036 error = cancel_lock(ls, lkb, &args);
6037
6038 if (error == -DLM_ECANCEL)
6039 error = 0;
David Teiglandef0c2bb2007-03-28 09:56:46 -05006040 /* from validate_unlock_args() */
6041 if (error == -EBUSY)
6042 error = 0;
David Teigland597d0ca2006-07-12 16:44:04 -05006043 out_put:
6044 dlm_put_lkb(lkb);
6045 out:
David Teigland85e86ed2007-05-18 08:58:15 -05006046 dlm_unlock_recovery(ls);
David Teiglandef0c2bb2007-03-28 09:56:46 -05006047 kfree(ua_tmp);
David Teigland597d0ca2006-07-12 16:44:04 -05006048 return error;
6049}
6050
David Teigland8b4021f2007-05-29 08:46:00 -05006051int dlm_user_deadlock(struct dlm_ls *ls, uint32_t flags, uint32_t lkid)
6052{
6053 struct dlm_lkb *lkb;
6054 struct dlm_args args;
6055 struct dlm_user_args *ua;
6056 struct dlm_rsb *r;
6057 int error;
6058
6059 dlm_lock_recovery(ls);
6060
6061 error = find_lkb(ls, lkid, &lkb);
6062 if (error)
6063 goto out;
6064
David Teiglandd292c0c2008-02-06 23:27:04 -06006065 ua = lkb->lkb_ua;
David Teigland8b4021f2007-05-29 08:46:00 -05006066
6067 error = set_unlock_args(flags, ua, &args);
6068 if (error)
6069 goto out_put;
6070
6071 /* same as cancel_lock(), but set DEADLOCK_CANCEL after lock_rsb */
6072
6073 r = lkb->lkb_resource;
6074 hold_rsb(r);
6075 lock_rsb(r);
6076
6077 error = validate_unlock_args(lkb, &args);
6078 if (error)
6079 goto out_r;
6080 lkb->lkb_flags |= DLM_IFL_DEADLOCK_CANCEL;
6081
6082 error = _cancel_lock(r, lkb);
6083 out_r:
6084 unlock_rsb(r);
6085 put_rsb(r);
6086
6087 if (error == -DLM_ECANCEL)
6088 error = 0;
6089 /* from validate_unlock_args() */
6090 if (error == -EBUSY)
6091 error = 0;
6092 out_put:
6093 dlm_put_lkb(lkb);
6094 out:
6095 dlm_unlock_recovery(ls);
6096 return error;
6097}
6098
David Teiglandef0c2bb2007-03-28 09:56:46 -05006099/* lkb's that are removed from the waiters list by revert are just left on the
6100 orphans list with the granted orphan locks, to be freed by purge */
6101
David Teigland597d0ca2006-07-12 16:44:04 -05006102static int orphan_proc_lock(struct dlm_ls *ls, struct dlm_lkb *lkb)
6103{
David Teiglandef0c2bb2007-03-28 09:56:46 -05006104 struct dlm_args args;
6105 int error;
David Teigland597d0ca2006-07-12 16:44:04 -05006106
David Teigland2ab4bd82014-10-17 11:05:50 -05006107 hold_lkb(lkb); /* reference for the ls_orphans list */
David Teiglandef0c2bb2007-03-28 09:56:46 -05006108 mutex_lock(&ls->ls_orphans_mutex);
6109 list_add_tail(&lkb->lkb_ownqueue, &ls->ls_orphans);
6110 mutex_unlock(&ls->ls_orphans_mutex);
David Teigland597d0ca2006-07-12 16:44:04 -05006111
David Teiglandd292c0c2008-02-06 23:27:04 -06006112 set_unlock_args(0, lkb->lkb_ua, &args);
David Teiglandef0c2bb2007-03-28 09:56:46 -05006113
6114 error = cancel_lock(ls, lkb, &args);
6115 if (error == -DLM_ECANCEL)
6116 error = 0;
6117 return error;
David Teigland597d0ca2006-07-12 16:44:04 -05006118}
6119
David Teiglandda8c6662012-11-15 15:01:51 -06006120/* The FORCEUNLOCK flag allows the unlock to go ahead even if the lkb isn't
6121 granted. Regardless of what rsb queue the lock is on, it's removed and
6122 freed. The IVVALBLK flag causes the lvb on the resource to be invalidated
6123 if our lock is PW/EX (it's ignored if our granted mode is smaller.) */
David Teigland597d0ca2006-07-12 16:44:04 -05006124
6125static int unlock_proc_lock(struct dlm_ls *ls, struct dlm_lkb *lkb)
6126{
David Teigland597d0ca2006-07-12 16:44:04 -05006127 struct dlm_args args;
6128 int error;
6129
David Teiglandda8c6662012-11-15 15:01:51 -06006130 set_unlock_args(DLM_LKF_FORCEUNLOCK | DLM_LKF_IVVALBLK,
6131 lkb->lkb_ua, &args);
David Teigland597d0ca2006-07-12 16:44:04 -05006132
6133 error = unlock_lock(ls, lkb, &args);
6134 if (error == -DLM_EUNLOCK)
6135 error = 0;
6136 return error;
6137}
6138
David Teiglandef0c2bb2007-03-28 09:56:46 -05006139/* We have to release clear_proc_locks mutex before calling unlock_proc_lock()
6140 (which does lock_rsb) due to deadlock with receiving a message that does
David Teigland23e8e1a2011-04-05 13:16:24 -05006141 lock_rsb followed by dlm_user_add_cb() */
David Teiglandef0c2bb2007-03-28 09:56:46 -05006142
6143static struct dlm_lkb *del_proc_lock(struct dlm_ls *ls,
6144 struct dlm_user_proc *proc)
6145{
6146 struct dlm_lkb *lkb = NULL;
6147
6148 mutex_lock(&ls->ls_clear_proc_locks);
6149 if (list_empty(&proc->locks))
6150 goto out;
6151
6152 lkb = list_entry(proc->locks.next, struct dlm_lkb, lkb_ownqueue);
6153 list_del_init(&lkb->lkb_ownqueue);
6154
6155 if (lkb->lkb_exflags & DLM_LKF_PERSISTENT)
6156 lkb->lkb_flags |= DLM_IFL_ORPHAN;
6157 else
6158 lkb->lkb_flags |= DLM_IFL_DEAD;
6159 out:
6160 mutex_unlock(&ls->ls_clear_proc_locks);
6161 return lkb;
6162}
6163
David Teigland23e8e1a2011-04-05 13:16:24 -05006164/* The ls_clear_proc_locks mutex protects against dlm_user_add_cb() which
David Teigland597d0ca2006-07-12 16:44:04 -05006165 1) references lkb->ua which we free here and 2) adds lkbs to proc->asts,
6166 which we clear here. */
6167
6168/* proc CLOSING flag is set so no more device_reads should look at proc->asts
6169 list, and no more device_writes should add lkb's to proc->locks list; so we
6170 shouldn't need to take asts_spin or locks_spin here. this assumes that
6171 device reads/writes/closes are serialized -- FIXME: we may need to serialize
6172 them ourself. */
6173
6174void dlm_clear_proc_locks(struct dlm_ls *ls, struct dlm_user_proc *proc)
6175{
6176 struct dlm_lkb *lkb, *safe;
6177
David Teigland85e86ed2007-05-18 08:58:15 -05006178 dlm_lock_recovery(ls);
David Teigland597d0ca2006-07-12 16:44:04 -05006179
David Teiglandef0c2bb2007-03-28 09:56:46 -05006180 while (1) {
6181 lkb = del_proc_lock(ls, proc);
6182 if (!lkb)
6183 break;
David Teigland84d8cd62007-05-29 08:44:23 -05006184 del_timeout(lkb);
David Teiglandef0c2bb2007-03-28 09:56:46 -05006185 if (lkb->lkb_exflags & DLM_LKF_PERSISTENT)
David Teigland597d0ca2006-07-12 16:44:04 -05006186 orphan_proc_lock(ls, lkb);
David Teiglandef0c2bb2007-03-28 09:56:46 -05006187 else
David Teigland597d0ca2006-07-12 16:44:04 -05006188 unlock_proc_lock(ls, lkb);
David Teigland597d0ca2006-07-12 16:44:04 -05006189
6190 /* this removes the reference for the proc->locks list
6191 added by dlm_user_request, it may result in the lkb
6192 being freed */
6193
6194 dlm_put_lkb(lkb);
6195 }
David Teiglanda1bc86e2007-01-15 10:34:52 -06006196
David Teiglandef0c2bb2007-03-28 09:56:46 -05006197 mutex_lock(&ls->ls_clear_proc_locks);
6198
David Teiglanda1bc86e2007-01-15 10:34:52 -06006199 /* in-progress unlocks */
6200 list_for_each_entry_safe(lkb, safe, &proc->unlocking, lkb_ownqueue) {
6201 list_del_init(&lkb->lkb_ownqueue);
6202 lkb->lkb_flags |= DLM_IFL_DEAD;
6203 dlm_put_lkb(lkb);
6204 }
6205
David Teigland23e8e1a2011-04-05 13:16:24 -05006206 list_for_each_entry_safe(lkb, safe, &proc->asts, lkb_cb_list) {
David Teigland8304d6f2011-02-21 14:58:21 -06006207 memset(&lkb->lkb_callbacks, 0,
6208 sizeof(struct dlm_callback) * DLM_CALLBACKS_SIZE);
David Teigland23e8e1a2011-04-05 13:16:24 -05006209 list_del_init(&lkb->lkb_cb_list);
David Teiglanda1bc86e2007-01-15 10:34:52 -06006210 dlm_put_lkb(lkb);
6211 }
6212
David Teigland597d0ca2006-07-12 16:44:04 -05006213 mutex_unlock(&ls->ls_clear_proc_locks);
David Teigland85e86ed2007-05-18 08:58:15 -05006214 dlm_unlock_recovery(ls);
David Teigland597d0ca2006-07-12 16:44:04 -05006215}
David Teiglanda1bc86e2007-01-15 10:34:52 -06006216
David Teigland84991372007-03-30 15:02:40 -05006217static void purge_proc_locks(struct dlm_ls *ls, struct dlm_user_proc *proc)
6218{
6219 struct dlm_lkb *lkb, *safe;
6220
6221 while (1) {
6222 lkb = NULL;
6223 spin_lock(&proc->locks_spin);
6224 if (!list_empty(&proc->locks)) {
6225 lkb = list_entry(proc->locks.next, struct dlm_lkb,
6226 lkb_ownqueue);
6227 list_del_init(&lkb->lkb_ownqueue);
6228 }
6229 spin_unlock(&proc->locks_spin);
6230
6231 if (!lkb)
6232 break;
6233
6234 lkb->lkb_flags |= DLM_IFL_DEAD;
6235 unlock_proc_lock(ls, lkb);
6236 dlm_put_lkb(lkb); /* ref from proc->locks list */
6237 }
6238
6239 spin_lock(&proc->locks_spin);
6240 list_for_each_entry_safe(lkb, safe, &proc->unlocking, lkb_ownqueue) {
6241 list_del_init(&lkb->lkb_ownqueue);
6242 lkb->lkb_flags |= DLM_IFL_DEAD;
6243 dlm_put_lkb(lkb);
6244 }
6245 spin_unlock(&proc->locks_spin);
6246
6247 spin_lock(&proc->asts_spin);
David Teigland23e8e1a2011-04-05 13:16:24 -05006248 list_for_each_entry_safe(lkb, safe, &proc->asts, lkb_cb_list) {
David Teigland8304d6f2011-02-21 14:58:21 -06006249 memset(&lkb->lkb_callbacks, 0,
6250 sizeof(struct dlm_callback) * DLM_CALLBACKS_SIZE);
David Teigland23e8e1a2011-04-05 13:16:24 -05006251 list_del_init(&lkb->lkb_cb_list);
David Teigland84991372007-03-30 15:02:40 -05006252 dlm_put_lkb(lkb);
6253 }
6254 spin_unlock(&proc->asts_spin);
6255}
6256
6257/* pid of 0 means purge all orphans */
6258
6259static void do_purge(struct dlm_ls *ls, int nodeid, int pid)
6260{
6261 struct dlm_lkb *lkb, *safe;
6262
6263 mutex_lock(&ls->ls_orphans_mutex);
6264 list_for_each_entry_safe(lkb, safe, &ls->ls_orphans, lkb_ownqueue) {
6265 if (pid && lkb->lkb_ownpid != pid)
6266 continue;
6267 unlock_proc_lock(ls, lkb);
6268 list_del_init(&lkb->lkb_ownqueue);
6269 dlm_put_lkb(lkb);
6270 }
6271 mutex_unlock(&ls->ls_orphans_mutex);
6272}
6273
6274static int send_purge(struct dlm_ls *ls, int nodeid, int pid)
6275{
6276 struct dlm_message *ms;
6277 struct dlm_mhandle *mh;
6278 int error;
6279
6280 error = _create_message(ls, sizeof(struct dlm_message), nodeid,
6281 DLM_MSG_PURGE, &ms, &mh);
6282 if (error)
6283 return error;
6284 ms->m_nodeid = nodeid;
6285 ms->m_pid = pid;
6286
6287 return send_message(mh, ms);
6288}
6289
6290int dlm_user_purge(struct dlm_ls *ls, struct dlm_user_proc *proc,
6291 int nodeid, int pid)
6292{
6293 int error = 0;
6294
David Teigland2ab4bd82014-10-17 11:05:50 -05006295 if (nodeid && (nodeid != dlm_our_nodeid())) {
David Teigland84991372007-03-30 15:02:40 -05006296 error = send_purge(ls, nodeid, pid);
6297 } else {
David Teigland85e86ed2007-05-18 08:58:15 -05006298 dlm_lock_recovery(ls);
David Teigland84991372007-03-30 15:02:40 -05006299 if (pid == current->pid)
6300 purge_proc_locks(ls, proc);
6301 else
6302 do_purge(ls, nodeid, pid);
David Teigland85e86ed2007-05-18 08:58:15 -05006303 dlm_unlock_recovery(ls);
David Teigland84991372007-03-30 15:02:40 -05006304 }
6305 return error;
6306}
6307