[mirror_ubuntu-eoan-kernel.git] / fs / gfs2 / locking / dlm / lock_dlm.h

/*
 * Copyright (C) Sistina Software, Inc.  1997-2003 All rights reserved.
 * Copyright (C) 2004-2005 Red Hat, Inc.  All rights reserved.
 *
 * This copyrighted material is made available to anyone wishing to use,
 * modify, copy, or redistribute it subject to the terms and conditions
 * of the GNU General Public License version 2.
 */

#ifndef LOCK_DLM_DOT_H
#define LOCK_DLM_DOT_H

#include <linux/module.h>
#include <linux/slab.h>
#include <linux/spinlock.h>
#include <linux/module.h>
#include <linux/types.h>
#include <linux/string.h>
#include <linux/list.h>
#include <linux/socket.h>
#include <linux/delay.h>
#include <linux/kthread.h>
#include <linux/kobject.h>
#include <linux/fcntl.h>
#include <linux/wait.h>
#include <net/sock.h>

#include <linux/dlm.h>
#include "../../lm_interface.h"

/*
 * Internally, we prefix things with gdlm_ and GDLM_ (for gfs-dlm) since a
 * prefix of lock_dlm_ gets awkward.  Externally, GFS refers to this module
 * as "lock_dlm".
 */

#define GDLM_STRNAME_BYTES	24
#define GDLM_LVB_SIZE		32
#define GDLM_DROP_COUNT		50000
#define GDLM_DROP_PERIOD	60
#define GDLM_NAME_LEN		128

/* GFS uses 12 bytes to identify a resource (32 bit type + 64 bit number).
   We sprintf these numbers into a 24 byte string of hex values to make them
   human-readable (to make debugging simpler.) */

struct gdlm_strname {
	unsigned char		name[GDLM_STRNAME_BYTES];
	unsigned short		namelen;
};

enum {
	DFL_BLOCK_LOCKS		= 0,
	DFL_SPECTATOR		= 1,
	DFL_WITHDRAW		= 2,
};

struct gdlm_ls {
	uint32_t		id;
	int			jid;
	int			first;
	int			first_done;
	unsigned long		flags;
	struct kobject		kobj;
	char			clustername[GDLM_NAME_LEN];
	char			fsname[GDLM_NAME_LEN];
	int			fsflags;
	dlm_lockspace_t		*dlm_lockspace;
	lm_callback_t		fscb;
	lm_fsdata_t		*fsdata;
	int			recover_jid;
	int			recover_jid_done;
	int			recover_jid_status;
	spinlock_t		async_lock;
	struct list_head	complete;
	struct list_head	blocking;
	struct list_head	delayed;
	struct list_head	submit;
	struct list_head	all_locks;
	uint32_t		all_locks_count;
	wait_queue_head_t	wait_control;
	struct task_struct	*thread1;
	struct task_struct	*thread2;
	wait_queue_head_t	thread_wait;
	unsigned long		drop_time;
	int			drop_locks_count;
	int			drop_locks_period;
};

enum {
	LFL_NOBLOCK		= 0,
	LFL_NOCACHE		= 1,
	LFL_DLM_UNLOCK		= 2,
	LFL_DLM_CANCEL		= 3,
	LFL_SYNC_LVB		= 4,
	LFL_FORCE_PROMOTE	= 5,
	LFL_REREQUEST		= 6,
	LFL_ACTIVE		= 7,
	LFL_INLOCK		= 8,
	LFL_CANCEL		= 9,
	LFL_NOBAST		= 10,
	LFL_HEADQUE		= 11,
	LFL_UNLOCK_DELETE	= 12,
};

struct gdlm_lock {
	struct gdlm_ls		*ls;
	struct lm_lockname	lockname;
	char			*lvb;
	struct dlm_lksb		lksb;

	int16_t			cur;
	int16_t			req;
	int16_t			prev_req;
	uint32_t		lkf;		/* dlm flags DLM_LKF_ */
	unsigned long		flags;		/* lock_dlm flags LFL_ */

	int			bast_mode;	/* protected by async_lock */
	struct completion	ast_wait;

	struct list_head	clist;		/* complete */
	struct list_head	blist;		/* blocking */
	struct list_head	delay_list;	/* delayed */
	struct list_head	all_list;	/* all locks for the fs */
	struct gdlm_lock	*hold_null;	/* NL lock for hold_lvb */
};

#define gdlm_assert(assertion, fmt, args...)                                  \
do {                                                                          \
	if (unlikely(!(assertion))) {                                         \
		printk(KERN_EMERG "lock_dlm: fatal assertion failed \"%s\"\n" \
				  "lock_dlm:  " fmt "\n",                     \
				  #assertion, ##args);                        \
		BUG();                                                        \
	}                                                                     \
} while (0)

#define log_print(lev, fmt, arg...) printk(lev "lock_dlm: " fmt "\n" , ## arg)
#define log_info(fmt, arg...)  log_print(KERN_INFO , fmt , ## arg)
#define log_error(fmt, arg...) log_print(KERN_ERR , fmt , ## arg)
#ifdef LOCK_DLM_LOG_DEBUG
#define log_debug(fmt, arg...) log_print(KERN_DEBUG , fmt , ## arg)
#else
#define log_debug(fmt, arg...)
#endif

/* sysfs.c */

int gdlm_sysfs_init(void);
void gdlm_sysfs_exit(void);
int gdlm_kobject_setup(struct gdlm_ls *, struct kobject *);
void gdlm_kobject_release(struct gdlm_ls *);

/* thread.c */

int gdlm_init_threads(struct gdlm_ls *);
void gdlm_release_threads(struct gdlm_ls *);

/* lock.c */

int16_t gdlm_make_lmstate(int16_t);
void gdlm_queue_delayed(struct gdlm_lock *);
void gdlm_submit_delayed(struct gdlm_ls *);
int gdlm_release_all_locks(struct gdlm_ls *);
void gdlm_delete_lp(struct gdlm_lock *);
unsigned int gdlm_do_lock(struct gdlm_lock *);

int gdlm_get_lock(lm_lockspace_t *, struct lm_lockname *, lm_lock_t **);
void gdlm_put_lock(lm_lock_t *);
unsigned int gdlm_lock(lm_lock_t *, unsigned int, unsigned int, unsigned int);
unsigned int gdlm_unlock(lm_lock_t *, unsigned int);
void gdlm_cancel(lm_lock_t *);
int gdlm_hold_lvb(lm_lock_t *, char **);
void gdlm_unhold_lvb(lm_lock_t *, char *);
void gdlm_sync_lvb(lm_lock_t *, char *);

/* plock.c */

int gdlm_plock_init(void);
void gdlm_plock_exit(void);
int gdlm_plock(lm_lockspace_t *, struct lm_lockname *, struct file *, int,
		struct file_lock *);
int gdlm_plock_get(lm_lockspace_t *, struct lm_lockname *, struct file *,
		struct file_lock *);
int gdlm_punlock(lm_lockspace_t *, struct lm_lockname *, struct file *,
		struct file_lock *);
#endif
Commit	Line	Data
869d81df DT	1	/*
	2	* Copyright (C) Sistina Software, Inc. 1997-2003 All rights reserved.
	3	* Copyright (C) 2004-2005 Red Hat, Inc. All rights reserved.
	4	*
	5	* This copyrighted material is made available to anyone wishing to use,
	6	* modify, copy, or redistribute it subject to the terms and conditions
e9fc2aa0	7	* of the GNU General Public License version 2.
869d81df DT	8	*/
	9
	10	#ifndef LOCK_DLM_DOT_H
	11	#define LOCK_DLM_DOT_H
	12
	13	#include <linux/module.h>
	14	#include <linux/slab.h>
	15	#include <linux/spinlock.h>
	16	#include <linux/module.h>
	17	#include <linux/types.h>
	18	#include <linux/string.h>
	19	#include <linux/list.h>
	20	#include <linux/socket.h>
	21	#include <linux/delay.h>
	22	#include <linux/kthread.h>
	23	#include <linux/kobject.h>
	24	#include <linux/fcntl.h>
	25	#include <linux/wait.h>
	26	#include <net/sock.h>
	27
	28	#include <linux/dlm.h>
	29	#include "../../lm_interface.h"
	30
	31	/*
	32	* Internally, we prefix things with gdlm_ and GDLM_ (for gfs-dlm) since a
	33	* prefix of lock_dlm_ gets awkward. Externally, GFS refers to this module
	34	* as "lock_dlm".
	35	*/
	36
	37	#define GDLM_STRNAME_BYTES 24
	38	#define GDLM_LVB_SIZE 32
	39	#define GDLM_DROP_COUNT 50000
	40	#define GDLM_DROP_PERIOD 60
	41	#define GDLM_NAME_LEN 128
	42
	43	/* GFS uses 12 bytes to identify a resource (32 bit type + 64 bit number).
	44	We sprintf these numbers into a 24 byte string of hex values to make them
	45	human-readable (to make debugging simpler.) */
	46
	47	struct gdlm_strname {
	48	unsigned char name[GDLM_STRNAME_BYTES];
	49	unsigned short namelen;
	50	};
	51
	52	enum {
	53	DFL_BLOCK_LOCKS = 0,
	54	DFL_SPECTATOR = 1,
	55	DFL_WITHDRAW = 2,
	56	};
	57
	58	struct gdlm_ls {
	59	uint32_t id;
	60	int jid;
	61	int first;
	62	int first_done;
	63	unsigned long flags;
	64	struct kobject kobj;
	65	char clustername[GDLM_NAME_LEN];
	66	char fsname[GDLM_NAME_LEN];
	67	int fsflags;
	68	dlm_lockspace_t *dlm_lockspace;
	69	lm_callback_t fscb;
	70	lm_fsdata_t *fsdata;
	71	int recover_jid;
72	int recover_jid_done;
6bd70aba	73	int recover_jid_status;
869d81df DT	74	spinlock_t async_lock;
	75	struct list_head complete;
	76	struct list_head blocking;
	77	struct list_head delayed;
	78	struct list_head submit;
	79	struct list_head all_locks;
	80	uint32_t all_locks_count;
	81	wait_queue_head_t wait_control;
	82	struct task_struct *thread1;
	83	struct task_struct *thread2;
	84	wait_queue_head_t thread_wait;
	85	unsigned long drop_time;
	86	int drop_locks_count;
	87	int drop_locks_period;
	88	};
	89
	90	enum {
	91	LFL_NOBLOCK = 0,
	92	LFL_NOCACHE = 1,
	93	LFL_DLM_UNLOCK = 2,
	94	LFL_DLM_CANCEL = 3,
	95	LFL_SYNC_LVB = 4,
	96	LFL_FORCE_PROMOTE = 5,
	97	LFL_REREQUEST = 6,
	98	LFL_ACTIVE = 7,
	99	LFL_INLOCK = 8,
	100	LFL_CANCEL = 9,
	101	LFL_NOBAST = 10,
	102	LFL_HEADQUE = 11,
	103	LFL_UNLOCK_DELETE = 12,
	104	};
	105
	106	struct gdlm_lock {
	107	struct gdlm_ls *ls;
	108	struct lm_lockname lockname;
	109	char *lvb;
	110	struct dlm_lksb lksb;
	111
	112	int16_t cur;
	113	int16_t req;
	114	int16_t prev_req;
	115	uint32_t lkf; /* dlm flags DLM_LKF_ */
	116	unsigned long flags; /* lock_dlm flags LFL_ */
	117
	118	int bast_mode; /* protected by async_lock */
	119	struct completion ast_wait;
	120
	121	struct list_head clist; /* complete */
	122	struct list_head blist; /* blocking */
	123	struct list_head delay_list; /* delayed */
	124	struct list_head all_list; /* all locks for the fs */
	125	struct gdlm_lock hold_null; / NL lock for hold_lvb */
	126	};
	127
	128	#define gdlm_assert(assertion, fmt, args...) \
	129	do { \
	130	if (unlikely(!(assertion))) { \
	131	printk(KERN_EMERG "lock_dlm: fatal assertion failed \"%s\"\n" \
	132	"lock_dlm: " fmt "\n", \
	133	#assertion, ##args); \
	134	BUG(); \
	135	} \
	136	} while (0)
	137
138	#define log_print(lev, fmt, arg...) printk(lev "lock_dlm: " fmt "\n" , ## arg)
139	#define log_info(fmt, arg...) log_print(KERN_INFO , fmt , ## arg)
140	#define log_error(fmt, arg...) log_print(KERN_ERR , fmt , ## arg)
141	#ifdef LOCK_DLM_LOG_DEBUG
142	#define log_debug(fmt, arg...) log_print(KERN_DEBUG , fmt , ## arg)
143	#else
144	#define log_debug(fmt, arg...)
145	#endif
146
147	/* sysfs.c */
148
149	int gdlm_sysfs_init(void);
150	void gdlm_sysfs_exit(void);
151	int gdlm_kobject_setup(struct gdlm_ls , struct kobject );
152	void gdlm_kobject_release(struct gdlm_ls *);
153
154	/* thread.c */
155
156	int gdlm_init_threads(struct gdlm_ls *);
157	void gdlm_release_threads(struct gdlm_ls *);
158
159	/* lock.c */
160
161	int16_t gdlm_make_lmstate(int16_t);
162	void gdlm_queue_delayed(struct gdlm_lock *);
163	void gdlm_submit_delayed(struct gdlm_ls *);
164	int gdlm_release_all_locks(struct gdlm_ls *);
869d81df	165	void gdlm_delete_lp(struct gdlm_lock *);
8d3b35a4	166	unsigned int gdlm_do_lock(struct gdlm_lock *);
869d81df DT	167
	168	int gdlm_get_lock(lm_lockspace_t , struct lm_lockname , lm_lock_t **);
	169	void gdlm_put_lock(lm_lock_t *);
	170	unsigned int gdlm_lock(lm_lock_t *, unsigned int, unsigned int, unsigned int);
	171	unsigned int gdlm_unlock(lm_lock_t *, unsigned int);
	172	void gdlm_cancel(lm_lock_t *);
	173	int gdlm_hold_lvb(lm_lock_t , char *);
	174	void gdlm_unhold_lvb(lm_lock_t , char );
	175	void gdlm_sync_lvb(lm_lock_t , char );
	176
	177	/* plock.c */
	178
	179	int gdlm_plock_init(void);
	180	void gdlm_plock_exit(void);
	181	int gdlm_plock(lm_lockspace_t , struct lm_lockname , struct file *, int,
	182	struct file_lock *);
	183	int gdlm_plock_get(lm_lockspace_t , struct lm_lockname , struct file *,
	184	struct file_lock *);
	185	int gdlm_punlock(lm_lockspace_t , struct lm_lockname , struct file *,
	186	struct file_lock *);
	187	#endif
	188