Commit | Line | Data |
---|---|---|
b3b94faa DT |
1 | /* |
2 | * Copyright (C) Sistina Software, Inc. 1997-2003 All rights reserved. | |
3a8a9a10 | 3 | * Copyright (C) 2004-2006 Red Hat, Inc. All rights reserved. |
b3b94faa DT |
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. |
b3b94faa DT |
8 | */ |
9 | ||
10 | #ifndef __LM_INTERFACE_DOT_H__ | |
11 | #define __LM_INTERFACE_DOT_H__ | |
12 | ||
b3b94faa | 13 | |
9b47c11d | 14 | typedef void (*lm_callback_t) (void *ptr, unsigned int type, void *data); |
b3b94faa DT |
15 | |
16 | /* | |
17 | * lm_mount() flags | |
18 | * | |
19 | * LM_MFLAG_SPECTATOR | |
20 | * GFS is asking to join the filesystem's lockspace, but it doesn't want to | |
21 | * modify the filesystem. The lock module shouldn't assign a journal to the FS | |
22 | * mount. It shouldn't send recovery callbacks to the FS mount. If the node | |
23 | * dies or withdraws, all locks can be wiped immediately. | |
24 | */ | |
25 | ||
26 | #define LM_MFLAG_SPECTATOR 0x00000001 | |
27 | ||
28 | /* | |
29 | * lm_lockstruct flags | |
30 | * | |
31 | * LM_LSFLAG_LOCAL | |
32 | * The lock_nolock module returns LM_LSFLAG_LOCAL to GFS, indicating that GFS | |
33 | * can make single-node optimizations. | |
34 | */ | |
35 | ||
36 | #define LM_LSFLAG_LOCAL 0x00000001 | |
37 | ||
38 | /* | |
39 | * lm_lockname types | |
40 | */ | |
41 | ||
42 | #define LM_TYPE_RESERVED 0x00 | |
43 | #define LM_TYPE_NONDISK 0x01 | |
44 | #define LM_TYPE_INODE 0x02 | |
45 | #define LM_TYPE_RGRP 0x03 | |
46 | #define LM_TYPE_META 0x04 | |
47 | #define LM_TYPE_IOPEN 0x05 | |
48 | #define LM_TYPE_FLOCK 0x06 | |
49 | #define LM_TYPE_PLOCK 0x07 | |
50 | #define LM_TYPE_QUOTA 0x08 | |
51 | #define LM_TYPE_JOURNAL 0x09 | |
52 | ||
53 | /* | |
54 | * lm_lock() states | |
55 | * | |
56 | * SHARED is compatible with SHARED, not with DEFERRED or EX. | |
57 | * DEFERRED is compatible with DEFERRED, not with SHARED or EX. | |
58 | */ | |
59 | ||
60 | #define LM_ST_UNLOCKED 0 | |
61 | #define LM_ST_EXCLUSIVE 1 | |
62 | #define LM_ST_DEFERRED 2 | |
63 | #define LM_ST_SHARED 3 | |
64 | ||
65 | /* | |
66 | * lm_lock() flags | |
67 | * | |
68 | * LM_FLAG_TRY | |
69 | * Don't wait to acquire the lock if it can't be granted immediately. | |
70 | * | |
71 | * LM_FLAG_TRY_1CB | |
72 | * Send one blocking callback if TRY is set and the lock is not granted. | |
73 | * | |
74 | * LM_FLAG_NOEXP | |
75 | * GFS sets this flag on lock requests it makes while doing journal recovery. | |
76 | * These special requests should not be blocked due to the recovery like | |
77 | * ordinary locks would be. | |
78 | * | |
79 | * LM_FLAG_ANY | |
80 | * A SHARED request may also be granted in DEFERRED, or a DEFERRED request may | |
81 | * also be granted in SHARED. The preferred state is whichever is compatible | |
82 | * with other granted locks, or the specified state if no other locks exist. | |
83 | * | |
84 | * LM_FLAG_PRIORITY | |
85 | * Override fairness considerations. Suppose a lock is held in a shared state | |
86 | * and there is a pending request for the deferred state. A shared lock | |
87 | * request with the priority flag would be allowed to bypass the deferred | |
88 | * request and directly join the other shared lock. A shared lock request | |
89 | * without the priority flag might be forced to wait until the deferred | |
90 | * requested had acquired and released the lock. | |
91 | */ | |
92 | ||
93 | #define LM_FLAG_TRY 0x00000001 | |
94 | #define LM_FLAG_TRY_1CB 0x00000002 | |
95 | #define LM_FLAG_NOEXP 0x00000004 | |
96 | #define LM_FLAG_ANY 0x00000008 | |
97 | #define LM_FLAG_PRIORITY 0x00000010 | |
98 | ||
99 | /* | |
100 | * lm_lock() and lm_async_cb return flags | |
101 | * | |
102 | * LM_OUT_ST_MASK | |
103 | * Masks the lower two bits of lock state in the returned value. | |
104 | * | |
105 | * LM_OUT_CACHEABLE | |
106 | * The lock hasn't been released so GFS can continue to cache data for it. | |
107 | * | |
108 | * LM_OUT_CANCELED | |
109 | * The lock request was canceled. | |
110 | * | |
111 | * LM_OUT_ASYNC | |
112 | * The result of the request will be returned in an LM_CB_ASYNC callback. | |
113 | */ | |
114 | ||
115 | #define LM_OUT_ST_MASK 0x00000003 | |
116 | #define LM_OUT_CACHEABLE 0x00000004 | |
117 | #define LM_OUT_CANCELED 0x00000008 | |
118 | #define LM_OUT_ASYNC 0x00000080 | |
119 | #define LM_OUT_ERROR 0x00000100 | |
120 | ||
121 | /* | |
122 | * lm_callback_t types | |
123 | * | |
124 | * LM_CB_NEED_E LM_CB_NEED_D LM_CB_NEED_S | |
125 | * Blocking callback, a remote node is requesting the given lock in | |
126 | * EXCLUSIVE, DEFERRED, or SHARED. | |
127 | * | |
128 | * LM_CB_NEED_RECOVERY | |
129 | * The given journal needs to be recovered. | |
130 | * | |
131 | * LM_CB_DROPLOCKS | |
132 | * Reduce the number of cached locks. | |
133 | * | |
134 | * LM_CB_ASYNC | |
135 | * The given lock has been granted. | |
136 | */ | |
137 | ||
138 | #define LM_CB_NEED_E 257 | |
139 | #define LM_CB_NEED_D 258 | |
140 | #define LM_CB_NEED_S 259 | |
141 | #define LM_CB_NEED_RECOVERY 260 | |
142 | #define LM_CB_DROPLOCKS 261 | |
143 | #define LM_CB_ASYNC 262 | |
144 | ||
145 | /* | |
146 | * lm_recovery_done() messages | |
147 | */ | |
148 | ||
149 | #define LM_RD_GAVEUP 308 | |
150 | #define LM_RD_SUCCESS 309 | |
151 | ||
152 | ||
153 | struct lm_lockname { | |
cd915493 | 154 | u64 ln_number; |
b3b94faa DT |
155 | unsigned int ln_type; |
156 | }; | |
157 | ||
158 | #define lm_name_equal(name1, name2) \ | |
159 | (((name1)->ln_number == (name2)->ln_number) && \ | |
160 | ((name1)->ln_type == (name2)->ln_type)) \ | |
161 | ||
162 | struct lm_async_cb { | |
163 | struct lm_lockname lc_name; | |
164 | int lc_ret; | |
165 | }; | |
166 | ||
167 | struct lm_lockstruct; | |
168 | ||
169 | struct lm_lockops { | |
9b47c11d | 170 | const char *lm_proto_name; |
b3b94faa DT |
171 | |
172 | /* | |
173 | * Mount/Unmount | |
174 | */ | |
175 | ||
176 | int (*lm_mount) (char *table_name, char *host_data, | |
9b47c11d | 177 | lm_callback_t cb, void *cb_data, |
b3b94faa DT |
178 | unsigned int min_lvb_size, int flags, |
179 | struct lm_lockstruct *lockstruct, | |
180 | struct kobject *fskobj); | |
181 | ||
9b47c11d | 182 | void (*lm_others_may_mount) (void *lockspace); |
b3b94faa | 183 | |
9b47c11d | 184 | void (*lm_unmount) (void *lockspace); |
b3b94faa | 185 | |
9b47c11d | 186 | void (*lm_withdraw) (void *lockspace); |
b3b94faa DT |
187 | |
188 | /* | |
189 | * Lock oriented operations | |
190 | */ | |
191 | ||
9b47c11d | 192 | int (*lm_get_lock) (void *lockspace, struct lm_lockname *name, void **lockp); |
b3b94faa | 193 | |
9b47c11d | 194 | void (*lm_put_lock) (void *lock); |
b3b94faa | 195 | |
9b47c11d | 196 | unsigned int (*lm_lock) (void *lock, unsigned int cur_state, |
b3b94faa DT |
197 | unsigned int req_state, unsigned int flags); |
198 | ||
9b47c11d | 199 | unsigned int (*lm_unlock) (void *lock, unsigned int cur_state); |
b3b94faa | 200 | |
9b47c11d | 201 | void (*lm_cancel) (void *lock); |
b3b94faa | 202 | |
9b47c11d SW |
203 | int (*lm_hold_lvb) (void *lock, char **lvbp); |
204 | void (*lm_unhold_lvb) (void *lock, char *lvb); | |
b3b94faa DT |
205 | |
206 | /* | |
207 | * Posix Lock oriented operations | |
208 | */ | |
209 | ||
9b47c11d | 210 | int (*lm_plock_get) (void *lockspace, struct lm_lockname *name, |
b3b94faa DT |
211 | struct file *file, struct file_lock *fl); |
212 | ||
9b47c11d | 213 | int (*lm_plock) (void *lockspace, struct lm_lockname *name, |
b3b94faa DT |
214 | struct file *file, int cmd, struct file_lock *fl); |
215 | ||
9b47c11d | 216 | int (*lm_punlock) (void *lockspace, struct lm_lockname *name, |
b3b94faa DT |
217 | struct file *file, struct file_lock *fl); |
218 | ||
219 | /* | |
220 | * Client oriented operations | |
221 | */ | |
222 | ||
9b47c11d | 223 | void (*lm_recovery_done) (void *lockspace, unsigned int jid, |
b3b94faa DT |
224 | unsigned int message); |
225 | ||
226 | struct module *lm_owner; | |
227 | }; | |
228 | ||
229 | /* | |
230 | * lm_mount() return values | |
231 | * | |
232 | * ls_jid - the journal ID this node should use | |
233 | * ls_first - this node is the first to mount the file system | |
234 | * ls_lvb_size - size in bytes of lock value blocks | |
235 | * ls_lockspace - lock module's context for this file system | |
236 | * ls_ops - lock module's functions | |
237 | * ls_flags - lock module features | |
238 | */ | |
239 | ||
240 | struct lm_lockstruct { | |
241 | unsigned int ls_jid; | |
242 | unsigned int ls_first; | |
243 | unsigned int ls_lvb_size; | |
9b47c11d SW |
244 | void *ls_lockspace; |
245 | const struct lm_lockops *ls_ops; | |
b3b94faa DT |
246 | int ls_flags; |
247 | }; | |
248 | ||
b3b94faa DT |
249 | /* |
250 | * Lock module bottom interface. A lock module makes itself available to GFS | |
251 | * with these functions. | |
b3b94faa DT |
252 | */ |
253 | ||
9b47c11d SW |
254 | int gfs2_register_lockproto(const struct lm_lockops *proto); |
255 | void gfs2_unregister_lockproto(const struct lm_lockops *proto); | |
b3b94faa DT |
256 | |
257 | /* | |
258 | * Lock module top interface. GFS calls these functions when mounting or | |
259 | * unmounting a file system. | |
260 | */ | |
261 | ||
262 | int gfs2_mount_lockproto(char *proto_name, char *table_name, char *host_data, | |
9b47c11d | 263 | lm_callback_t cb, void *cb_data, |
b3b94faa DT |
264 | unsigned int min_lvb_size, int flags, |
265 | struct lm_lockstruct *lockstruct, | |
266 | struct kobject *fskobj); | |
267 | ||
268 | void gfs2_unmount_lockproto(struct lm_lockstruct *lockstruct); | |
269 | ||
270 | void gfs2_withdraw_lockproto(struct lm_lockstruct *lockstruct); | |
271 | ||
272 | #endif /* __LM_INTERFACE_DOT_H__ */ | |
273 |