serial: replace remaining __FUNCTION__ occurrences
[linux-2.6.git] / fs / ocfs2 / stackglue.h
1 /* -*- mode: c; c-basic-offset: 8; -*-
2  * vim: noexpandtab sw=8 ts=8 sts=0:
3  *
4  * stackglue.h
5  *
6  * Glue to the underlying cluster stack.
7  *
8  * Copyright (C) 2007 Oracle.  All rights reserved.
9  *
10  * This program is free software; you can redistribute it and/or
11  * modify it under the terms of the GNU General Public
12  * License as published by the Free Software Foundation, version 2.
13  *
14  * This program is distributed in the hope that it will be useful,
15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
17  * General Public License for more details.
18  */
19
20
21 #ifndef STACKGLUE_H
22 #define STACKGLUE_H
23
24 #include <linux/types.h>
25 #include <linux/list.h>
26 #include <linux/dlmconstants.h>
27
28 #include "dlm/dlmapi.h"
29 #include <linux/dlm.h>
30
31 /*
32  * dlmconstants.h does not have a LOCAL flag.  We hope to remove it
33  * some day, but right now we need it.  Let's fake it.  This value is larger
34  * than any flag in dlmconstants.h.
35  */
36 #define DLM_LKF_LOCAL           0x00100000
37
38 /*
39  * This shadows DLM_LOCKSPACE_LEN in fs/dlm/dlm_internal.h.  That probably
40  * wants to be in a public header.
41  */
42 #define GROUP_NAME_MAX          64
43
44
45 /*
46  * ocfs2_protocol_version changes when ocfs2 does something different in
47  * its inter-node behavior.  See dlmglue.c for more information.
48  */
49 struct ocfs2_protocol_version {
50         u8 pv_major;
51         u8 pv_minor;
52 };
53
54 /*
55  * The ocfs2_locking_protocol defines the handlers called on ocfs2's behalf.
56  */
57 struct ocfs2_locking_protocol {
58         struct ocfs2_protocol_version lp_max_version;
59         void (*lp_lock_ast)(void *astarg);
60         void (*lp_blocking_ast)(void *astarg, int level);
61         void (*lp_unlock_ast)(void *astarg, int error);
62 };
63
64
65 /*
66  * The dlm_lockstatus struct includes lvb space, but the dlm_lksb struct only
67  * has a pointer to separately allocated lvb space.  This struct exists only to
68  * include in the lksb union to make space for a combined dlm_lksb and lvb.
69  */
70 struct fsdlm_lksb_plus_lvb {
71         struct dlm_lksb lksb;
72         char lvb[DLM_LVB_LEN];
73 };
74
75 /*
76  * A union of all lock status structures.  We define it here so that the
77  * size of the union is known.  Lock status structures are embedded in
78  * ocfs2 inodes.
79  */
80 union ocfs2_dlm_lksb {
81         struct dlm_lockstatus lksb_o2dlm;
82         struct dlm_lksb lksb_fsdlm;
83         struct fsdlm_lksb_plus_lvb padding;
84 };
85
86 /*
87  * A cluster connection.  Mostly opaque to ocfs2, the connection holds
88  * state for the underlying stack.  ocfs2 does use cc_version to determine
89  * locking compatibility.
90  */
91 struct ocfs2_cluster_connection {
92         char cc_name[GROUP_NAME_MAX];
93         int cc_namelen;
94         struct ocfs2_protocol_version cc_version;
95         void (*cc_recovery_handler)(int node_num, void *recovery_data);
96         void *cc_recovery_data;
97         void *cc_lockspace;
98         void *cc_private;
99 };
100
101 /*
102  * Each cluster stack implements the stack operations structure.  Not used
103  * in the ocfs2 code, the stackglue code translates generic cluster calls
104  * into stack operations.
105  */
106 struct ocfs2_stack_operations {
107         /*
108          * The fs code calls ocfs2_cluster_connect() to attach a new
109          * filesystem to the cluster stack.  The ->connect() op is passed
110          * an ocfs2_cluster_connection with the name and recovery field
111          * filled in.
112          *
113          * The stack must set up any notification mechanisms and create
114          * the filesystem lockspace in the DLM.  The lockspace should be
115          * stored on cc_lockspace.  Any other information can be stored on
116          * cc_private.
117          *
118          * ->connect() must not return until it is guaranteed that
119          *
120          *  - Node down notifications for the filesystem will be recieved
121          *    and passed to conn->cc_recovery_handler().
122          *  - Locking requests for the filesystem will be processed.
123          */
124         int (*connect)(struct ocfs2_cluster_connection *conn);
125
126         /*
127          * The fs code calls ocfs2_cluster_disconnect() when a filesystem
128          * no longer needs cluster services.  All DLM locks have been
129          * dropped, and recovery notification is being ignored by the
130          * fs code.  The stack must disengage from the DLM and discontinue
131          * recovery notification.
132          *
133          * Once ->disconnect() has returned, the connection structure will
134          * be freed.  Thus, a stack must not return from ->disconnect()
135          * until it will no longer reference the conn pointer.
136          *
137          * If hangup_pending is zero, ocfs2_cluster_disconnect() will also
138          * be dropping the reference on the module.
139          */
140         int (*disconnect)(struct ocfs2_cluster_connection *conn,
141                           int hangup_pending);
142
143         /*
144          * ocfs2_cluster_hangup() exists for compatibility with older
145          * ocfs2 tools.  Only the classic stack really needs it.  As such
146          * ->hangup() is not required of all stacks.  See the comment by
147          * ocfs2_cluster_hangup() for more details.
148          *
149          * Note that ocfs2_cluster_hangup() can only be called if
150          * hangup_pending was passed to ocfs2_cluster_disconnect().
151          */
152         void (*hangup)(const char *group, int grouplen);
153
154         /*
155          * ->this_node() returns the cluster's unique identifier for the
156          * local node.
157          */
158         int (*this_node)(unsigned int *node);
159
160         /*
161          * Call the underlying dlm lock function.  The ->dlm_lock()
162          * callback should convert the flags and mode as appropriate.
163          *
164          * ast and bast functions are not part of the call because the
165          * stack will likely want to wrap ast and bast calls before passing
166          * them to stack->sp_proto.
167          */
168         int (*dlm_lock)(struct ocfs2_cluster_connection *conn,
169                         int mode,
170                         union ocfs2_dlm_lksb *lksb,
171                         u32 flags,
172                         void *name,
173                         unsigned int namelen,
174                         void *astarg);
175
176         /*
177          * Call the underlying dlm unlock function.  The ->dlm_unlock()
178          * function should convert the flags as appropriate.
179          *
180          * The unlock ast is not passed, as the stack will want to wrap
181          * it before calling stack->sp_proto->lp_unlock_ast().
182          */
183         int (*dlm_unlock)(struct ocfs2_cluster_connection *conn,
184                           union ocfs2_dlm_lksb *lksb,
185                           u32 flags,
186                           void *astarg);
187
188         /*
189          * Return the status of the current lock status block.  The fs
190          * code should never dereference the union.  The ->lock_status()
191          * callback pulls out the stack-specific lksb, converts the status
192          * to a proper errno, and returns it.
193          */
194         int (*lock_status)(union ocfs2_dlm_lksb *lksb);
195
196         /*
197          * Pull the lvb pointer off of the stack-specific lksb.
198          */
199         void *(*lock_lvb)(union ocfs2_dlm_lksb *lksb);
200
201         /*
202          * This is an optoinal debugging hook.  If provided, the
203          * stack can dump debugging information about this lock.
204          */
205         void (*dump_lksb)(union ocfs2_dlm_lksb *lksb);
206 };
207
208 /*
209  * Each stack plugin must describe itself by registering a
210  * ocfs2_stack_plugin structure.  This is only seen by stackglue and the
211  * stack driver.
212  */
213 struct ocfs2_stack_plugin {
214         char *sp_name;
215         struct ocfs2_stack_operations *sp_ops;
216         struct module *sp_owner;
217
218         /* These are managed by the stackglue code. */
219         struct list_head sp_list;
220         unsigned int sp_count;
221         struct ocfs2_locking_protocol *sp_proto;
222 };
223
224
225 /* Used by the filesystem */
226 int ocfs2_cluster_connect(const char *stack_name,
227                           const char *group,
228                           int grouplen,
229                           void (*recovery_handler)(int node_num,
230                                                    void *recovery_data),
231                           void *recovery_data,
232                           struct ocfs2_cluster_connection **conn);
233 int ocfs2_cluster_disconnect(struct ocfs2_cluster_connection *conn,
234                              int hangup_pending);
235 void ocfs2_cluster_hangup(const char *group, int grouplen);
236 int ocfs2_cluster_this_node(unsigned int *node);
237
238 struct ocfs2_lock_res;
239 int ocfs2_dlm_lock(struct ocfs2_cluster_connection *conn,
240                    int mode,
241                    union ocfs2_dlm_lksb *lksb,
242                    u32 flags,
243                    void *name,
244                    unsigned int namelen,
245                    struct ocfs2_lock_res *astarg);
246 int ocfs2_dlm_unlock(struct ocfs2_cluster_connection *conn,
247                      union ocfs2_dlm_lksb *lksb,
248                      u32 flags,
249                      struct ocfs2_lock_res *astarg);
250
251 int ocfs2_dlm_lock_status(union ocfs2_dlm_lksb *lksb);
252 void *ocfs2_dlm_lvb(union ocfs2_dlm_lksb *lksb);
253 void ocfs2_dlm_dump_lksb(union ocfs2_dlm_lksb *lksb);
254
255 void ocfs2_stack_glue_set_locking_protocol(struct ocfs2_locking_protocol *proto);
256
257
258 /* Used by stack plugins */
259 int ocfs2_stack_glue_register(struct ocfs2_stack_plugin *plugin);
260 void ocfs2_stack_glue_unregister(struct ocfs2_stack_plugin *plugin);
261 #endif  /* STACKGLUE_H */