xref: /openbmc/linux/fs/ocfs2/dlm/dlmcommon.h (revision 22246614)
1 /* -*- mode: c; c-basic-offset: 8; -*-
2  * vim: noexpandtab sw=8 ts=8 sts=0:
3  *
4  * dlmcommon.h
5  *
6  * Copyright (C) 2004 Oracle.  All rights reserved.
7  *
8  * This program is free software; you can redistribute it and/or
9  * modify it under the terms of the GNU General Public
10  * License as published by the Free Software Foundation; either
11  * version 2 of the License, or (at your option) any later version.
12  *
13  * This program is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
16  * General Public License for more details.
17  *
18  * You should have received a copy of the GNU General Public
19  * License along with this program; if not, write to the
20  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
21  * Boston, MA 021110-1307, USA.
22  *
23  */
24 
25 #ifndef DLMCOMMON_H
26 #define DLMCOMMON_H
27 
28 #include <linux/kref.h>
29 
30 #define DLM_HB_NODE_DOWN_PRI     (0xf000000)
31 #define DLM_HB_NODE_UP_PRI       (0x8000000)
32 
33 #define DLM_LOCKID_NAME_MAX    32
34 
35 #define DLM_DOMAIN_NAME_MAX_LEN    255
36 #define DLM_LOCK_RES_OWNER_UNKNOWN     O2NM_MAX_NODES
37 #define DLM_THREAD_SHUFFLE_INTERVAL    5     // flush everything every 5 passes
38 #define DLM_THREAD_MS                  200   // flush at least every 200 ms
39 
40 #define DLM_HASH_SIZE_DEFAULT	(1 << 14)
41 #if DLM_HASH_SIZE_DEFAULT < PAGE_SIZE
42 # define DLM_HASH_PAGES		1
43 #else
44 # define DLM_HASH_PAGES		(DLM_HASH_SIZE_DEFAULT / PAGE_SIZE)
45 #endif
46 #define DLM_BUCKETS_PER_PAGE	(PAGE_SIZE / sizeof(struct hlist_head))
47 #define DLM_HASH_BUCKETS	(DLM_HASH_PAGES * DLM_BUCKETS_PER_PAGE)
48 
49 /* Intended to make it easier for us to switch out hash functions */
50 #define dlm_lockid_hash(_n, _l) full_name_hash(_n, _l)
51 
52 enum dlm_mle_type {
53 	DLM_MLE_BLOCK,
54 	DLM_MLE_MASTER,
55 	DLM_MLE_MIGRATION
56 };
57 
58 struct dlm_lock_name {
59 	u8 len;
60 	u8 name[DLM_LOCKID_NAME_MAX];
61 };
62 
63 struct dlm_master_list_entry {
64 	struct list_head list;
65 	struct list_head hb_events;
66 	struct dlm_ctxt *dlm;
67 	spinlock_t spinlock;
68 	wait_queue_head_t wq;
69 	atomic_t woken;
70 	struct kref mle_refs;
71 	int inuse;
72 	unsigned long maybe_map[BITS_TO_LONGS(O2NM_MAX_NODES)];
73 	unsigned long vote_map[BITS_TO_LONGS(O2NM_MAX_NODES)];
74 	unsigned long response_map[BITS_TO_LONGS(O2NM_MAX_NODES)];
75 	unsigned long node_map[BITS_TO_LONGS(O2NM_MAX_NODES)];
76 	u8 master;
77 	u8 new_master;
78 	enum dlm_mle_type type;
79 	struct o2hb_callback_func mle_hb_up;
80 	struct o2hb_callback_func mle_hb_down;
81 	union {
82 		struct dlm_lock_resource *res;
83 		struct dlm_lock_name name;
84 	} u;
85 };
86 
87 enum dlm_ast_type {
88 	DLM_AST = 0,
89 	DLM_BAST,
90 	DLM_ASTUNLOCK
91 };
92 
93 
94 #define LKM_VALID_FLAGS (LKM_VALBLK | LKM_CONVERT | LKM_UNLOCK | \
95 			 LKM_CANCEL | LKM_INVVALBLK | LKM_FORCE | \
96 			 LKM_RECOVERY | LKM_LOCAL | LKM_NOQUEUE)
97 
98 #define DLM_RECOVERY_LOCK_NAME       "$RECOVERY"
99 #define DLM_RECOVERY_LOCK_NAME_LEN   9
100 
101 static inline int dlm_is_recovery_lock(const char *lock_name, int name_len)
102 {
103 	if (name_len == DLM_RECOVERY_LOCK_NAME_LEN &&
104 	    memcmp(lock_name, DLM_RECOVERY_LOCK_NAME, name_len)==0)
105 		return 1;
106 	return 0;
107 }
108 
109 #define DLM_RECO_STATE_ACTIVE    0x0001
110 #define DLM_RECO_STATE_FINALIZE  0x0002
111 
112 struct dlm_recovery_ctxt
113 {
114 	struct list_head resources;
115 	struct list_head received;
116 	struct list_head node_data;
117 	u8  new_master;
118 	u8  dead_node;
119 	u16 state;
120 	unsigned long node_map[BITS_TO_LONGS(O2NM_MAX_NODES)];
121 	wait_queue_head_t event;
122 };
123 
124 enum dlm_ctxt_state {
125 	DLM_CTXT_NEW = 0,
126 	DLM_CTXT_JOINED,
127 	DLM_CTXT_IN_SHUTDOWN,
128 	DLM_CTXT_LEAVING,
129 };
130 
131 struct dlm_ctxt
132 {
133 	struct list_head list;
134 	struct hlist_head **lockres_hash;
135 	struct list_head dirty_list;
136 	struct list_head purge_list;
137 	struct list_head pending_asts;
138 	struct list_head pending_basts;
139 	struct list_head tracking_list;
140 	unsigned int purge_count;
141 	spinlock_t spinlock;
142 	spinlock_t ast_lock;
143 	char *name;
144 	u8 node_num;
145 	u32 key;
146 	u8  joining_node;
147 	wait_queue_head_t dlm_join_events;
148 	unsigned long live_nodes_map[BITS_TO_LONGS(O2NM_MAX_NODES)];
149 	unsigned long domain_map[BITS_TO_LONGS(O2NM_MAX_NODES)];
150 	unsigned long recovery_map[BITS_TO_LONGS(O2NM_MAX_NODES)];
151 	struct dlm_recovery_ctxt reco;
152 	spinlock_t master_lock;
153 	struct list_head master_list;
154 	struct list_head mle_hb_events;
155 
156 	/* these give a really vague idea of the system load */
157 	atomic_t local_resources;
158 	atomic_t remote_resources;
159 	atomic_t unknown_resources;
160 
161 	struct dlm_debug_ctxt *dlm_debug_ctxt;
162 	struct dentry *dlm_debugfs_subroot;
163 
164 	/* NOTE: Next three are protected by dlm_domain_lock */
165 	struct kref dlm_refs;
166 	enum dlm_ctxt_state dlm_state;
167 	unsigned int num_joins;
168 
169 	struct o2hb_callback_func dlm_hb_up;
170 	struct o2hb_callback_func dlm_hb_down;
171 	struct task_struct *dlm_thread_task;
172 	struct task_struct *dlm_reco_thread_task;
173 	struct workqueue_struct *dlm_worker;
174 	wait_queue_head_t dlm_thread_wq;
175 	wait_queue_head_t dlm_reco_thread_wq;
176 	wait_queue_head_t ast_wq;
177 	wait_queue_head_t migration_wq;
178 
179 	struct work_struct dispatched_work;
180 	struct list_head work_list;
181 	spinlock_t work_lock;
182 	struct list_head dlm_domain_handlers;
183 	struct list_head	dlm_eviction_callbacks;
184 
185 	/* The filesystem specifies this at domain registration.  We
186 	 * cache it here to know what to tell other nodes. */
187 	struct dlm_protocol_version fs_locking_proto;
188 	/* This is the inter-dlm communication version */
189 	struct dlm_protocol_version dlm_locking_proto;
190 };
191 
192 static inline struct hlist_head *dlm_lockres_hash(struct dlm_ctxt *dlm, unsigned i)
193 {
194 	return dlm->lockres_hash[(i / DLM_BUCKETS_PER_PAGE) % DLM_HASH_PAGES] + (i % DLM_BUCKETS_PER_PAGE);
195 }
196 
197 /* these keventd work queue items are for less-frequently
198  * called functions that cannot be directly called from the
199  * net message handlers for some reason, usually because
200  * they need to send net messages of their own. */
201 void dlm_dispatch_work(struct work_struct *work);
202 
203 struct dlm_lock_resource;
204 struct dlm_work_item;
205 
206 typedef void (dlm_workfunc_t)(struct dlm_work_item *, void *);
207 
208 struct dlm_request_all_locks_priv
209 {
210 	u8 reco_master;
211 	u8 dead_node;
212 };
213 
214 struct dlm_mig_lockres_priv
215 {
216 	struct dlm_lock_resource *lockres;
217 	u8 real_master;
218 	u8 extra_ref;
219 };
220 
221 struct dlm_assert_master_priv
222 {
223 	struct dlm_lock_resource *lockres;
224 	u8 request_from;
225 	u32 flags;
226 	unsigned ignore_higher:1;
227 };
228 
229 struct dlm_deref_lockres_priv
230 {
231 	struct dlm_lock_resource *deref_res;
232 	u8 deref_node;
233 };
234 
235 struct dlm_work_item
236 {
237 	struct list_head list;
238 	dlm_workfunc_t *func;
239 	struct dlm_ctxt *dlm;
240 	void *data;
241 	union {
242 		struct dlm_request_all_locks_priv ral;
243 		struct dlm_mig_lockres_priv ml;
244 		struct dlm_assert_master_priv am;
245 		struct dlm_deref_lockres_priv dl;
246 	} u;
247 };
248 
249 static inline void dlm_init_work_item(struct dlm_ctxt *dlm,
250 				      struct dlm_work_item *i,
251 				      dlm_workfunc_t *f, void *data)
252 {
253 	memset(i, 0, sizeof(*i));
254 	i->func = f;
255 	INIT_LIST_HEAD(&i->list);
256 	i->data = data;
257 	i->dlm = dlm;  /* must have already done a dlm_grab on this! */
258 }
259 
260 
261 
262 static inline void __dlm_set_joining_node(struct dlm_ctxt *dlm,
263 					  u8 node)
264 {
265 	assert_spin_locked(&dlm->spinlock);
266 
267 	dlm->joining_node = node;
268 	wake_up(&dlm->dlm_join_events);
269 }
270 
271 #define DLM_LOCK_RES_UNINITED             0x00000001
272 #define DLM_LOCK_RES_RECOVERING           0x00000002
273 #define DLM_LOCK_RES_READY                0x00000004
274 #define DLM_LOCK_RES_DIRTY                0x00000008
275 #define DLM_LOCK_RES_IN_PROGRESS          0x00000010
276 #define DLM_LOCK_RES_MIGRATING            0x00000020
277 #define DLM_LOCK_RES_DROPPING_REF         0x00000040
278 #define DLM_LOCK_RES_BLOCK_DIRTY          0x00001000
279 #define DLM_LOCK_RES_SETREF_INPROG        0x00002000
280 
281 /* max milliseconds to wait to sync up a network failure with a node death */
282 #define DLM_NODE_DEATH_WAIT_MAX (5 * 1000)
283 
284 #define DLM_PURGE_INTERVAL_MS   (8 * 1000)
285 
286 struct dlm_lock_resource
287 {
288 	/* WARNING: Please see the comment in dlm_init_lockres before
289 	 * adding fields here. */
290 	struct hlist_node hash_node;
291 	struct qstr lockname;
292 	struct kref      refs;
293 
294 	/*
295 	 * Please keep granted, converting, and blocked in this order,
296 	 * as some funcs want to iterate over all lists.
297 	 *
298 	 * All four lists are protected by the hash's reference.
299 	 */
300 	struct list_head granted;
301 	struct list_head converting;
302 	struct list_head blocked;
303 	struct list_head purge;
304 
305 	/*
306 	 * These two lists require you to hold an additional reference
307 	 * while they are on the list.
308 	 */
309 	struct list_head dirty;
310 	struct list_head recovering; // dlm_recovery_ctxt.resources list
311 
312 	/* Added during init and removed during release */
313 	struct list_head tracking;	/* dlm->tracking_list */
314 
315 	/* unused lock resources have their last_used stamped and are
316 	 * put on a list for the dlm thread to run. */
317 	unsigned long    last_used;
318 
319 	unsigned migration_pending:1;
320 	atomic_t asts_reserved;
321 	spinlock_t spinlock;
322 	wait_queue_head_t wq;
323 	u8  owner;              //node which owns the lock resource, or unknown
324 	u16 state;
325 	char lvb[DLM_LVB_LEN];
326 	unsigned int inflight_locks;
327 	unsigned long refmap[BITS_TO_LONGS(O2NM_MAX_NODES)];
328 };
329 
330 struct dlm_migratable_lock
331 {
332 	__be64 cookie;
333 
334 	/* these 3 are just padding for the in-memory structure, but
335 	 * list and flags are actually used when sent over the wire */
336 	__be16 pad1;
337 	u8 list;  // 0=granted, 1=converting, 2=blocked
338 	u8 flags;
339 
340 	s8 type;
341 	s8 convert_type;
342 	s8 highest_blocked;
343 	u8 node;
344 };  // 16 bytes
345 
346 struct dlm_lock
347 {
348 	struct dlm_migratable_lock ml;
349 
350 	struct list_head list;
351 	struct list_head ast_list;
352 	struct list_head bast_list;
353 	struct dlm_lock_resource *lockres;
354 	spinlock_t spinlock;
355 	struct kref lock_refs;
356 
357 	// ast and bast must be callable while holding a spinlock!
358 	dlm_astlockfunc_t *ast;
359 	dlm_bastlockfunc_t *bast;
360 	void *astdata;
361 	struct dlm_lockstatus *lksb;
362 	unsigned ast_pending:1,
363 		 bast_pending:1,
364 		 convert_pending:1,
365 		 lock_pending:1,
366 		 cancel_pending:1,
367 		 unlock_pending:1,
368 		 lksb_kernel_allocated:1;
369 };
370 
371 
372 #define DLM_LKSB_UNUSED1           0x01
373 #define DLM_LKSB_PUT_LVB           0x02
374 #define DLM_LKSB_GET_LVB           0x04
375 #define DLM_LKSB_UNUSED2           0x08
376 #define DLM_LKSB_UNUSED3           0x10
377 #define DLM_LKSB_UNUSED4           0x20
378 #define DLM_LKSB_UNUSED5           0x40
379 #define DLM_LKSB_UNUSED6           0x80
380 
381 
382 enum dlm_lockres_list {
383 	DLM_GRANTED_LIST = 0,
384 	DLM_CONVERTING_LIST,
385 	DLM_BLOCKED_LIST
386 };
387 
388 static inline int dlm_lvb_is_empty(char *lvb)
389 {
390 	int i;
391 	for (i=0; i<DLM_LVB_LEN; i++)
392 		if (lvb[i])
393 			return 0;
394 	return 1;
395 }
396 
397 static inline struct list_head *
398 dlm_list_idx_to_ptr(struct dlm_lock_resource *res, enum dlm_lockres_list idx)
399 {
400 	struct list_head *ret = NULL;
401 	if (idx == DLM_GRANTED_LIST)
402 		ret = &res->granted;
403 	else if (idx == DLM_CONVERTING_LIST)
404 		ret = &res->converting;
405 	else if (idx == DLM_BLOCKED_LIST)
406 		ret = &res->blocked;
407 	else
408 		BUG();
409 	return ret;
410 }
411 
412 
413 
414 
415 struct dlm_node_iter
416 {
417 	unsigned long node_map[BITS_TO_LONGS(O2NM_MAX_NODES)];
418 	int curnode;
419 };
420 
421 
422 enum {
423 	DLM_MASTER_REQUEST_MSG    = 500,
424 	DLM_UNUSED_MSG1,         /* 501 */
425 	DLM_ASSERT_MASTER_MSG,	 /* 502 */
426 	DLM_CREATE_LOCK_MSG,	 /* 503 */
427 	DLM_CONVERT_LOCK_MSG,	 /* 504 */
428 	DLM_PROXY_AST_MSG,	 /* 505 */
429 	DLM_UNLOCK_LOCK_MSG,	 /* 506 */
430 	DLM_DEREF_LOCKRES_MSG,	 /* 507 */
431 	DLM_MIGRATE_REQUEST_MSG, /* 508 */
432 	DLM_MIG_LOCKRES_MSG, 	 /* 509 */
433 	DLM_QUERY_JOIN_MSG,	 /* 510 */
434 	DLM_ASSERT_JOINED_MSG,	 /* 511 */
435 	DLM_CANCEL_JOIN_MSG,	 /* 512 */
436 	DLM_EXIT_DOMAIN_MSG,	 /* 513 */
437 	DLM_MASTER_REQUERY_MSG,	 /* 514 */
438 	DLM_LOCK_REQUEST_MSG,	 /* 515 */
439 	DLM_RECO_DATA_DONE_MSG,	 /* 516 */
440 	DLM_BEGIN_RECO_MSG,	 /* 517 */
441 	DLM_FINALIZE_RECO_MSG	 /* 518 */
442 };
443 
444 struct dlm_reco_node_data
445 {
446 	int state;
447 	u8 node_num;
448 	struct list_head list;
449 };
450 
451 enum {
452 	DLM_RECO_NODE_DATA_DEAD = -1,
453 	DLM_RECO_NODE_DATA_INIT = 0,
454 	DLM_RECO_NODE_DATA_REQUESTING,
455 	DLM_RECO_NODE_DATA_REQUESTED,
456 	DLM_RECO_NODE_DATA_RECEIVING,
457 	DLM_RECO_NODE_DATA_DONE,
458 	DLM_RECO_NODE_DATA_FINALIZE_SENT,
459 };
460 
461 
462 enum {
463 	DLM_MASTER_RESP_NO = 0,
464 	DLM_MASTER_RESP_YES,
465 	DLM_MASTER_RESP_MAYBE,
466 	DLM_MASTER_RESP_ERROR
467 };
468 
469 
470 struct dlm_master_request
471 {
472 	u8 node_idx;
473 	u8 namelen;
474 	__be16 pad1;
475 	__be32 flags;
476 
477 	u8 name[O2NM_MAX_NAME_LEN];
478 };
479 
480 #define DLM_ASSERT_RESPONSE_REASSERT       0x00000001
481 #define DLM_ASSERT_RESPONSE_MASTERY_REF    0x00000002
482 
483 #define DLM_ASSERT_MASTER_MLE_CLEANUP      0x00000001
484 #define DLM_ASSERT_MASTER_REQUERY          0x00000002
485 #define DLM_ASSERT_MASTER_FINISH_MIGRATION 0x00000004
486 struct dlm_assert_master
487 {
488 	u8 node_idx;
489 	u8 namelen;
490 	__be16 pad1;
491 	__be32 flags;
492 
493 	u8 name[O2NM_MAX_NAME_LEN];
494 };
495 
496 #define DLM_MIGRATE_RESPONSE_MASTERY_REF   0x00000001
497 
498 struct dlm_migrate_request
499 {
500 	u8 master;
501 	u8 new_master;
502 	u8 namelen;
503 	u8 pad1;
504 	__be32 pad2;
505 	u8 name[O2NM_MAX_NAME_LEN];
506 };
507 
508 struct dlm_master_requery
509 {
510 	u8 pad1;
511 	u8 pad2;
512 	u8 node_idx;
513 	u8 namelen;
514 	__be32 pad3;
515 	u8 name[O2NM_MAX_NAME_LEN];
516 };
517 
518 #define DLM_MRES_RECOVERY   0x01
519 #define DLM_MRES_MIGRATION  0x02
520 #define DLM_MRES_ALL_DONE   0x04
521 
522 /*
523  * We would like to get one whole lockres into a single network
524  * message whenever possible.  Generally speaking, there will be
525  * at most one dlm_lock on a lockres for each node in the cluster,
526  * plus (infrequently) any additional locks coming in from userdlm.
527  *
528  * struct _dlm_lockres_page
529  * {
530  * 	dlm_migratable_lockres mres;
531  * 	dlm_migratable_lock ml[DLM_MAX_MIGRATABLE_LOCKS];
532  * 	u8 pad[DLM_MIG_LOCKRES_RESERVED];
533  * };
534  *
535  * from ../cluster/tcp.h
536  *    NET_MAX_PAYLOAD_BYTES  (4096 - sizeof(net_msg))
537  *    (roughly 4080 bytes)
538  * and sizeof(dlm_migratable_lockres) = 112 bytes
539  * and sizeof(dlm_migratable_lock) = 16 bytes
540  *
541  * Choosing DLM_MAX_MIGRATABLE_LOCKS=240 and
542  * DLM_MIG_LOCKRES_RESERVED=128 means we have this:
543  *
544  *  (DLM_MAX_MIGRATABLE_LOCKS * sizeof(dlm_migratable_lock)) +
545  *     sizeof(dlm_migratable_lockres) + DLM_MIG_LOCKRES_RESERVED =
546  *        NET_MAX_PAYLOAD_BYTES
547  *  (240 * 16) + 112 + 128 = 4080
548  *
549  * So a lockres would need more than 240 locks before it would
550  * use more than one network packet to recover.  Not too bad.
551  */
552 #define DLM_MAX_MIGRATABLE_LOCKS   240
553 
554 struct dlm_migratable_lockres
555 {
556 	u8 master;
557 	u8 lockname_len;
558 	u8 num_locks;    // locks sent in this structure
559 	u8 flags;
560 	__be32 total_locks; // locks to be sent for this migration cookie
561 	__be64 mig_cookie;  // cookie for this lockres migration
562 			 // or zero if not needed
563 	// 16 bytes
564 	u8 lockname[DLM_LOCKID_NAME_MAX];
565 	// 48 bytes
566 	u8 lvb[DLM_LVB_LEN];
567 	// 112 bytes
568 	struct dlm_migratable_lock ml[0];  // 16 bytes each, begins at byte 112
569 };
570 #define DLM_MIG_LOCKRES_MAX_LEN  \
571 	(sizeof(struct dlm_migratable_lockres) + \
572 	 (sizeof(struct dlm_migratable_lock) * \
573 	  DLM_MAX_MIGRATABLE_LOCKS) )
574 
575 /* from above, 128 bytes
576  * for some undetermined future use */
577 #define DLM_MIG_LOCKRES_RESERVED   (NET_MAX_PAYLOAD_BYTES - \
578 				    DLM_MIG_LOCKRES_MAX_LEN)
579 
580 struct dlm_create_lock
581 {
582 	__be64 cookie;
583 
584 	__be32 flags;
585 	u8 pad1;
586 	u8 node_idx;
587 	s8 requested_type;
588 	u8 namelen;
589 
590 	u8 name[O2NM_MAX_NAME_LEN];
591 };
592 
593 struct dlm_convert_lock
594 {
595 	__be64 cookie;
596 
597 	__be32 flags;
598 	u8 pad1;
599 	u8 node_idx;
600 	s8 requested_type;
601 	u8 namelen;
602 
603 	u8 name[O2NM_MAX_NAME_LEN];
604 
605 	s8 lvb[0];
606 };
607 #define DLM_CONVERT_LOCK_MAX_LEN  (sizeof(struct dlm_convert_lock)+DLM_LVB_LEN)
608 
609 struct dlm_unlock_lock
610 {
611 	__be64 cookie;
612 
613 	__be32 flags;
614 	__be16 pad1;
615 	u8 node_idx;
616 	u8 namelen;
617 
618 	u8 name[O2NM_MAX_NAME_LEN];
619 
620 	s8 lvb[0];
621 };
622 #define DLM_UNLOCK_LOCK_MAX_LEN  (sizeof(struct dlm_unlock_lock)+DLM_LVB_LEN)
623 
624 struct dlm_proxy_ast
625 {
626 	__be64 cookie;
627 
628 	__be32 flags;
629 	u8 node_idx;
630 	u8 type;
631 	u8 blocked_type;
632 	u8 namelen;
633 
634 	u8 name[O2NM_MAX_NAME_LEN];
635 
636 	s8 lvb[0];
637 };
638 #define DLM_PROXY_AST_MAX_LEN  (sizeof(struct dlm_proxy_ast)+DLM_LVB_LEN)
639 
640 #define DLM_MOD_KEY (0x666c6172)
641 enum dlm_query_join_response_code {
642 	JOIN_DISALLOW = 0,
643 	JOIN_OK,
644 	JOIN_OK_NO_MAP,
645 	JOIN_PROTOCOL_MISMATCH,
646 };
647 
648 struct dlm_query_join_packet {
649 	u8 code;	/* Response code.  dlm_minor and fs_minor
650 			   are only valid if this is JOIN_OK */
651 	u8 dlm_minor;	/* The minor version of the protocol the
652 			   dlm is speaking. */
653 	u8 fs_minor;	/* The minor version of the protocol the
654 			   filesystem is speaking. */
655 	u8 reserved;
656 };
657 
658 union dlm_query_join_response {
659 	u32 intval;
660 	struct dlm_query_join_packet packet;
661 };
662 
663 struct dlm_lock_request
664 {
665 	u8 node_idx;
666 	u8 dead_node;
667 	__be16 pad1;
668 	__be32 pad2;
669 };
670 
671 struct dlm_reco_data_done
672 {
673 	u8 node_idx;
674 	u8 dead_node;
675 	__be16 pad1;
676 	__be32 pad2;
677 
678 	/* unused for now */
679 	/* eventually we can use this to attempt
680 	 * lvb recovery based on each node's info */
681 	u8 reco_lvb[DLM_LVB_LEN];
682 };
683 
684 struct dlm_begin_reco
685 {
686 	u8 node_idx;
687 	u8 dead_node;
688 	__be16 pad1;
689 	__be32 pad2;
690 };
691 
692 
693 #define BITS_PER_BYTE 8
694 #define BITS_TO_BYTES(bits) (((bits)+BITS_PER_BYTE-1)/BITS_PER_BYTE)
695 
696 struct dlm_query_join_request
697 {
698 	u8 node_idx;
699 	u8 pad1[2];
700 	u8 name_len;
701 	struct dlm_protocol_version dlm_proto;
702 	struct dlm_protocol_version fs_proto;
703 	u8 domain[O2NM_MAX_NAME_LEN];
704 	u8 node_map[BITS_TO_BYTES(O2NM_MAX_NODES)];
705 };
706 
707 struct dlm_assert_joined
708 {
709 	u8 node_idx;
710 	u8 pad1[2];
711 	u8 name_len;
712 	u8 domain[O2NM_MAX_NAME_LEN];
713 };
714 
715 struct dlm_cancel_join
716 {
717 	u8 node_idx;
718 	u8 pad1[2];
719 	u8 name_len;
720 	u8 domain[O2NM_MAX_NAME_LEN];
721 };
722 
723 struct dlm_exit_domain
724 {
725 	u8 node_idx;
726 	u8 pad1[3];
727 };
728 
729 struct dlm_finalize_reco
730 {
731 	u8 node_idx;
732 	u8 dead_node;
733 	u8 flags;
734 	u8 pad1;
735 	__be32 pad2;
736 };
737 
738 struct dlm_deref_lockres
739 {
740 	u32 pad1;
741 	u16 pad2;
742 	u8 node_idx;
743 	u8 namelen;
744 
745 	u8 name[O2NM_MAX_NAME_LEN];
746 };
747 
748 static inline enum dlm_status
749 __dlm_lockres_state_to_status(struct dlm_lock_resource *res)
750 {
751 	enum dlm_status status = DLM_NORMAL;
752 
753 	assert_spin_locked(&res->spinlock);
754 
755 	if (res->state & DLM_LOCK_RES_RECOVERING)
756 		status = DLM_RECOVERING;
757 	else if (res->state & DLM_LOCK_RES_MIGRATING)
758 		status = DLM_MIGRATING;
759 	else if (res->state & DLM_LOCK_RES_IN_PROGRESS)
760 		status = DLM_FORWARD;
761 
762 	return status;
763 }
764 
765 static inline u8 dlm_get_lock_cookie_node(u64 cookie)
766 {
767 	u8 ret;
768 	cookie >>= 56;
769 	ret = (u8)(cookie & 0xffULL);
770 	return ret;
771 }
772 
773 static inline unsigned long long dlm_get_lock_cookie_seq(u64 cookie)
774 {
775 	unsigned long long ret;
776 	ret = ((unsigned long long)cookie) & 0x00ffffffffffffffULL;
777 	return ret;
778 }
779 
780 struct dlm_lock * dlm_new_lock(int type, u8 node, u64 cookie,
781 			       struct dlm_lockstatus *lksb);
782 void dlm_lock_get(struct dlm_lock *lock);
783 void dlm_lock_put(struct dlm_lock *lock);
784 
785 void dlm_lock_attach_lockres(struct dlm_lock *lock,
786 			     struct dlm_lock_resource *res);
787 
788 int dlm_create_lock_handler(struct o2net_msg *msg, u32 len, void *data,
789 			    void **ret_data);
790 int dlm_convert_lock_handler(struct o2net_msg *msg, u32 len, void *data,
791 			     void **ret_data);
792 int dlm_proxy_ast_handler(struct o2net_msg *msg, u32 len, void *data,
793 			  void **ret_data);
794 
795 void dlm_revert_pending_convert(struct dlm_lock_resource *res,
796 				struct dlm_lock *lock);
797 void dlm_revert_pending_lock(struct dlm_lock_resource *res,
798 			     struct dlm_lock *lock);
799 
800 int dlm_unlock_lock_handler(struct o2net_msg *msg, u32 len, void *data,
801 			    void **ret_data);
802 void dlm_commit_pending_cancel(struct dlm_lock_resource *res,
803 			       struct dlm_lock *lock);
804 void dlm_commit_pending_unlock(struct dlm_lock_resource *res,
805 			       struct dlm_lock *lock);
806 
807 int dlm_launch_thread(struct dlm_ctxt *dlm);
808 void dlm_complete_thread(struct dlm_ctxt *dlm);
809 int dlm_launch_recovery_thread(struct dlm_ctxt *dlm);
810 void dlm_complete_recovery_thread(struct dlm_ctxt *dlm);
811 void dlm_wait_for_recovery(struct dlm_ctxt *dlm);
812 void dlm_kick_recovery_thread(struct dlm_ctxt *dlm);
813 int dlm_is_node_dead(struct dlm_ctxt *dlm, u8 node);
814 int dlm_wait_for_node_death(struct dlm_ctxt *dlm, u8 node, int timeout);
815 int dlm_wait_for_node_recovery(struct dlm_ctxt *dlm, u8 node, int timeout);
816 
817 void dlm_put(struct dlm_ctxt *dlm);
818 struct dlm_ctxt *dlm_grab(struct dlm_ctxt *dlm);
819 int dlm_domain_fully_joined(struct dlm_ctxt *dlm);
820 
821 void __dlm_lockres_calc_usage(struct dlm_ctxt *dlm,
822 			      struct dlm_lock_resource *res);
823 void dlm_lockres_calc_usage(struct dlm_ctxt *dlm,
824 			    struct dlm_lock_resource *res);
825 static inline void dlm_lockres_get(struct dlm_lock_resource *res)
826 {
827 	/* This is called on every lookup, so it might be worth
828 	 * inlining. */
829 	kref_get(&res->refs);
830 }
831 void dlm_lockres_put(struct dlm_lock_resource *res);
832 void __dlm_unhash_lockres(struct dlm_lock_resource *res);
833 void __dlm_insert_lockres(struct dlm_ctxt *dlm,
834 			  struct dlm_lock_resource *res);
835 struct dlm_lock_resource * __dlm_lookup_lockres_full(struct dlm_ctxt *dlm,
836 						     const char *name,
837 						     unsigned int len,
838 						     unsigned int hash);
839 struct dlm_lock_resource * __dlm_lookup_lockres(struct dlm_ctxt *dlm,
840 						const char *name,
841 						unsigned int len,
842 						unsigned int hash);
843 struct dlm_lock_resource * dlm_lookup_lockres(struct dlm_ctxt *dlm,
844 					      const char *name,
845 					      unsigned int len);
846 
847 int dlm_is_host_down(int errno);
848 void dlm_change_lockres_owner(struct dlm_ctxt *dlm,
849 			      struct dlm_lock_resource *res,
850 			      u8 owner);
851 struct dlm_lock_resource * dlm_get_lock_resource(struct dlm_ctxt *dlm,
852 						 const char *lockid,
853 						 int namelen,
854 						 int flags);
855 struct dlm_lock_resource *dlm_new_lockres(struct dlm_ctxt *dlm,
856 					  const char *name,
857 					  unsigned int namelen);
858 
859 #define dlm_lockres_set_refmap_bit(bit,res)  \
860 	__dlm_lockres_set_refmap_bit(bit,res,__FILE__,__LINE__)
861 #define dlm_lockres_clear_refmap_bit(bit,res)  \
862 	__dlm_lockres_clear_refmap_bit(bit,res,__FILE__,__LINE__)
863 
864 static inline void __dlm_lockres_set_refmap_bit(int bit,
865 						struct dlm_lock_resource *res,
866 						const char *file,
867 						int line)
868 {
869 	//printk("%s:%d:%.*s: setting bit %d\n", file, line,
870 	//     res->lockname.len, res->lockname.name, bit);
871 	set_bit(bit, res->refmap);
872 }
873 
874 static inline void __dlm_lockres_clear_refmap_bit(int bit,
875 						  struct dlm_lock_resource *res,
876 						  const char *file,
877 						  int line)
878 {
879 	//printk("%s:%d:%.*s: clearing bit %d\n", file, line,
880 	//     res->lockname.len, res->lockname.name, bit);
881 	clear_bit(bit, res->refmap);
882 }
883 
884 void __dlm_lockres_drop_inflight_ref(struct dlm_ctxt *dlm,
885 				   struct dlm_lock_resource *res,
886 				   const char *file,
887 				   int line);
888 void __dlm_lockres_grab_inflight_ref(struct dlm_ctxt *dlm,
889 				   struct dlm_lock_resource *res,
890 				   int new_lockres,
891 				   const char *file,
892 				   int line);
893 #define dlm_lockres_drop_inflight_ref(d,r)  \
894 	__dlm_lockres_drop_inflight_ref(d,r,__FILE__,__LINE__)
895 #define dlm_lockres_grab_inflight_ref(d,r)  \
896 	__dlm_lockres_grab_inflight_ref(d,r,0,__FILE__,__LINE__)
897 #define dlm_lockres_grab_inflight_ref_new(d,r)  \
898 	__dlm_lockres_grab_inflight_ref(d,r,1,__FILE__,__LINE__)
899 
900 void dlm_queue_ast(struct dlm_ctxt *dlm, struct dlm_lock *lock);
901 void dlm_queue_bast(struct dlm_ctxt *dlm, struct dlm_lock *lock);
902 void dlm_do_local_ast(struct dlm_ctxt *dlm,
903 		      struct dlm_lock_resource *res,
904 		      struct dlm_lock *lock);
905 int dlm_do_remote_ast(struct dlm_ctxt *dlm,
906 		      struct dlm_lock_resource *res,
907 		      struct dlm_lock *lock);
908 void dlm_do_local_bast(struct dlm_ctxt *dlm,
909 		       struct dlm_lock_resource *res,
910 		       struct dlm_lock *lock,
911 		       int blocked_type);
912 int dlm_send_proxy_ast_msg(struct dlm_ctxt *dlm,
913 			   struct dlm_lock_resource *res,
914 			   struct dlm_lock *lock,
915 			   int msg_type,
916 			   int blocked_type, int flags);
917 static inline int dlm_send_proxy_bast(struct dlm_ctxt *dlm,
918 				      struct dlm_lock_resource *res,
919 				      struct dlm_lock *lock,
920 				      int blocked_type)
921 {
922 	return dlm_send_proxy_ast_msg(dlm, res, lock, DLM_BAST,
923 				      blocked_type, 0);
924 }
925 
926 static inline int dlm_send_proxy_ast(struct dlm_ctxt *dlm,
927 				     struct dlm_lock_resource *res,
928 				     struct dlm_lock *lock,
929 				     int flags)
930 {
931 	return dlm_send_proxy_ast_msg(dlm, res, lock, DLM_AST,
932 				      0, flags);
933 }
934 
935 void dlm_print_one_lock_resource(struct dlm_lock_resource *res);
936 void __dlm_print_one_lock_resource(struct dlm_lock_resource *res);
937 
938 u8 dlm_nm_this_node(struct dlm_ctxt *dlm);
939 void dlm_kick_thread(struct dlm_ctxt *dlm, struct dlm_lock_resource *res);
940 void __dlm_dirty_lockres(struct dlm_ctxt *dlm, struct dlm_lock_resource *res);
941 
942 
943 int dlm_nm_init(struct dlm_ctxt *dlm);
944 int dlm_heartbeat_init(struct dlm_ctxt *dlm);
945 void dlm_hb_node_down_cb(struct o2nm_node *node, int idx, void *data);
946 void dlm_hb_node_up_cb(struct o2nm_node *node, int idx, void *data);
947 
948 int dlm_empty_lockres(struct dlm_ctxt *dlm, struct dlm_lock_resource *res);
949 int dlm_finish_migration(struct dlm_ctxt *dlm,
950 			 struct dlm_lock_resource *res,
951 			 u8 old_master);
952 void dlm_lockres_release_ast(struct dlm_ctxt *dlm,
953 			     struct dlm_lock_resource *res);
954 void __dlm_lockres_reserve_ast(struct dlm_lock_resource *res);
955 
956 int dlm_master_request_handler(struct o2net_msg *msg, u32 len, void *data,
957 			       void **ret_data);
958 int dlm_assert_master_handler(struct o2net_msg *msg, u32 len, void *data,
959 			      void **ret_data);
960 void dlm_assert_master_post_handler(int status, void *data, void *ret_data);
961 int dlm_deref_lockres_handler(struct o2net_msg *msg, u32 len, void *data,
962 			      void **ret_data);
963 int dlm_migrate_request_handler(struct o2net_msg *msg, u32 len, void *data,
964 				void **ret_data);
965 int dlm_mig_lockres_handler(struct o2net_msg *msg, u32 len, void *data,
966 			    void **ret_data);
967 int dlm_master_requery_handler(struct o2net_msg *msg, u32 len, void *data,
968 			       void **ret_data);
969 int dlm_request_all_locks_handler(struct o2net_msg *msg, u32 len, void *data,
970 				  void **ret_data);
971 int dlm_reco_data_done_handler(struct o2net_msg *msg, u32 len, void *data,
972 			       void **ret_data);
973 int dlm_begin_reco_handler(struct o2net_msg *msg, u32 len, void *data,
974 			   void **ret_data);
975 int dlm_finalize_reco_handler(struct o2net_msg *msg, u32 len, void *data,
976 			      void **ret_data);
977 int dlm_do_master_requery(struct dlm_ctxt *dlm, struct dlm_lock_resource *res,
978 			  u8 nodenum, u8 *real_master);
979 
980 
981 int dlm_dispatch_assert_master(struct dlm_ctxt *dlm,
982 			       struct dlm_lock_resource *res,
983 			       int ignore_higher,
984 			       u8 request_from,
985 			       u32 flags);
986 
987 
988 int dlm_send_one_lockres(struct dlm_ctxt *dlm,
989 			 struct dlm_lock_resource *res,
990 			 struct dlm_migratable_lockres *mres,
991 			 u8 send_to,
992 			 u8 flags);
993 void dlm_move_lockres_to_recovery_list(struct dlm_ctxt *dlm,
994 				       struct dlm_lock_resource *res);
995 
996 /* will exit holding res->spinlock, but may drop in function */
997 void __dlm_wait_on_lockres_flags(struct dlm_lock_resource *res, int flags);
998 void __dlm_wait_on_lockres_flags_set(struct dlm_lock_resource *res, int flags);
999 
1000 /* will exit holding res->spinlock, but may drop in function */
1001 static inline void __dlm_wait_on_lockres(struct dlm_lock_resource *res)
1002 {
1003 	__dlm_wait_on_lockres_flags(res, (DLM_LOCK_RES_IN_PROGRESS|
1004 				    	  DLM_LOCK_RES_RECOVERING|
1005 					  DLM_LOCK_RES_MIGRATING));
1006 }
1007 
1008 /* create/destroy slab caches */
1009 int dlm_init_master_caches(void);
1010 void dlm_destroy_master_caches(void);
1011 
1012 int dlm_init_lock_cache(void);
1013 void dlm_destroy_lock_cache(void);
1014 
1015 int dlm_init_mle_cache(void);
1016 void dlm_destroy_mle_cache(void);
1017 
1018 void dlm_hb_event_notify_attached(struct dlm_ctxt *dlm, int idx, int node_up);
1019 int dlm_drop_lockres_ref(struct dlm_ctxt *dlm,
1020 			 struct dlm_lock_resource *res);
1021 void dlm_clean_master_list(struct dlm_ctxt *dlm,
1022 			   u8 dead_node);
1023 int dlm_lock_basts_flushed(struct dlm_ctxt *dlm, struct dlm_lock *lock);
1024 int __dlm_lockres_has_locks(struct dlm_lock_resource *res);
1025 int __dlm_lockres_unused(struct dlm_lock_resource *res);
1026 
1027 static inline const char * dlm_lock_mode_name(int mode)
1028 {
1029 	switch (mode) {
1030 		case LKM_EXMODE:
1031 			return "EX";
1032 		case LKM_PRMODE:
1033 			return "PR";
1034 		case LKM_NLMODE:
1035 			return "NL";
1036 	}
1037 	return "UNKNOWN";
1038 }
1039 
1040 
1041 static inline int dlm_lock_compatible(int existing, int request)
1042 {
1043 	/* NO_LOCK compatible with all */
1044 	if (request == LKM_NLMODE ||
1045 	    existing == LKM_NLMODE)
1046 		return 1;
1047 
1048 	/* EX incompatible with all non-NO_LOCK */
1049 	if (request == LKM_EXMODE)
1050 		return 0;
1051 
1052 	/* request must be PR, which is compatible with PR */
1053 	if (existing == LKM_PRMODE)
1054 		return 1;
1055 
1056 	return 0;
1057 }
1058 
1059 static inline int dlm_lock_on_list(struct list_head *head,
1060 				   struct dlm_lock *lock)
1061 {
1062 	struct list_head *iter;
1063 	struct dlm_lock *tmplock;
1064 
1065 	list_for_each(iter, head) {
1066 		tmplock = list_entry(iter, struct dlm_lock, list);
1067 		if (tmplock == lock)
1068 			return 1;
1069 	}
1070 	return 0;
1071 }
1072 
1073 
1074 static inline enum dlm_status dlm_err_to_dlm_status(int err)
1075 {
1076 	enum dlm_status ret;
1077 	if (err == -ENOMEM)
1078 		ret = DLM_SYSERR;
1079 	else if (err == -ETIMEDOUT || o2net_link_down(err, NULL))
1080 		ret = DLM_NOLOCKMGR;
1081 	else if (err == -EINVAL)
1082 		ret = DLM_BADPARAM;
1083 	else if (err == -ENAMETOOLONG)
1084 		ret = DLM_IVBUFLEN;
1085 	else
1086 		ret = DLM_BADARGS;
1087 	return ret;
1088 }
1089 
1090 
1091 static inline void dlm_node_iter_init(unsigned long *map,
1092 				      struct dlm_node_iter *iter)
1093 {
1094 	memcpy(iter->node_map, map, sizeof(iter->node_map));
1095 	iter->curnode = -1;
1096 }
1097 
1098 static inline int dlm_node_iter_next(struct dlm_node_iter *iter)
1099 {
1100 	int bit;
1101 	bit = find_next_bit(iter->node_map, O2NM_MAX_NODES, iter->curnode+1);
1102 	if (bit >= O2NM_MAX_NODES) {
1103 		iter->curnode = O2NM_MAX_NODES;
1104 		return -ENOENT;
1105 	}
1106 	iter->curnode = bit;
1107 	return bit;
1108 }
1109 
1110 
1111 
1112 #endif /* DLMCOMMON_H */
1113