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