lock_dlm.h 4.48 KB
Newer Older
1 2 3 4 5 6
/*
 * 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
7
 * of the GNU General Public License version 2.
8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27
 */

#ifndef LOCK_DLM_DOT_H
#define LOCK_DLM_DOT_H

#include <linux/module.h>
#include <linux/slab.h>
#include <linux/spinlock.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>
28
#include <linux/dlm_plock.h>
29
#include <linux/lm_interface.h>
30 31 32 33 34 35 36 37 38

/*
 * 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
39
#define GDLM_DROP_COUNT		0
40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58
#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 {
59
	u32		id;
60 61 62 63 64 65 66 67 68 69
	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;
Steven Whitehouse's avatar
Steven Whitehouse committed
70
	struct gfs2_sbd		*sdp;
71 72
	int			recover_jid;
	int			recover_jid_done;
73
	int			recover_jid_status;
74 75 76 77
	spinlock_t		async_lock;
	struct list_head	delayed;
	struct list_head	submit;
	struct list_head	all_locks;
78
	u32		all_locks_count;
79
	wait_queue_head_t	wait_control;
80
	struct task_struct	*thread;
81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100
	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,
101
	LFL_AST_WAIT		= 13,
102 103 104 105 106
};

struct gdlm_lock {
	struct gdlm_ls		*ls;
	struct lm_lockname	lockname;
107
	struct gdlm_strname	strname;
108 109 110
	char			*lvb;
	struct dlm_lksb		lksb;

111 112 113
	s16			cur;
	s16			req;
	s16			prev_req;
114
	u32			lkf;		/* dlm flags DLM_LKF_ */
115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156
	unsigned long		flags;		/* lock_dlm flags LFL_ */

	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 */

void gdlm_submit_delayed(struct gdlm_ls *);
int gdlm_release_all_locks(struct gdlm_ls *);
157
unsigned int gdlm_do_lock(struct gdlm_lock *);
158

159 160 161 162 163 164 165
int gdlm_get_lock(void *, struct lm_lockname *, void **);
void gdlm_put_lock(void *);
unsigned int gdlm_lock(void *, unsigned int, unsigned int, unsigned int);
unsigned int gdlm_unlock(void *, unsigned int);
void gdlm_cancel(void *);
int gdlm_hold_lvb(void *, char **);
void gdlm_unhold_lvb(void *, char *);
166

167 168 169 170
/* mount.c */

extern const struct lm_lockops gdlm_ops;

171 172
#endif