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 /* Needed for plock-related prototypes */ 32 struct file; 33 struct file_lock; 34 35 /* 36 * dlmconstants.h does not have a LOCAL flag. We hope to remove it 37 * some day, but right now we need it. Let's fake it. This value is larger 38 * than any flag in dlmconstants.h. 39 */ 40 #define DLM_LKF_LOCAL 0x00100000 41 42 /* 43 * This shadows DLM_LOCKSPACE_LEN in fs/dlm/dlm_internal.h. That probably 44 * wants to be in a public header. 45 */ 46 #define GROUP_NAME_MAX 64 47 48 /* This shadows OCFS2_CLUSTER_NAME_LEN */ 49 #define CLUSTER_NAME_MAX 16 50 51 52 /* 53 * ocfs2_protocol_version changes when ocfs2 does something different in 54 * its inter-node behavior. See dlmglue.c for more information. 55 */ 56 struct ocfs2_protocol_version { 57 u8 pv_major; 58 u8 pv_minor; 59 }; 60 61 /* 62 * The dlm_lockstatus struct includes lvb space, but the dlm_lksb struct only 63 * has a pointer to separately allocated lvb space. This struct exists only to 64 * include in the lksb union to make space for a combined dlm_lksb and lvb. 65 */ 66 struct fsdlm_lksb_plus_lvb { 67 struct dlm_lksb lksb; 68 char lvb[DLM_LVB_LEN]; 69 }; 70 71 /* 72 * A union of all lock status structures. We define it here so that the 73 * size of the union is known. Lock status structures are embedded in 74 * ocfs2 inodes. 75 */ 76 struct ocfs2_cluster_connection; 77 struct ocfs2_dlm_lksb { 78 union { 79 struct dlm_lockstatus lksb_o2dlm; 80 struct dlm_lksb lksb_fsdlm; 81 struct fsdlm_lksb_plus_lvb padding; 82 }; 83 struct ocfs2_cluster_connection *lksb_conn; 84 }; 85 86 /* 87 * The ocfs2_locking_protocol defines the handlers called on ocfs2's behalf. 88 */ 89 struct ocfs2_locking_protocol { 90 struct ocfs2_protocol_version lp_max_version; 91 void (*lp_lock_ast)(struct ocfs2_dlm_lksb *lksb); 92 void (*lp_blocking_ast)(struct ocfs2_dlm_lksb *lksb, int level); 93 void (*lp_unlock_ast)(struct ocfs2_dlm_lksb *lksb, int error); 94 }; 95 96 97 /* 98 * A cluster connection. Mostly opaque to ocfs2, the connection holds 99 * state for the underlying stack. ocfs2 does use cc_version to determine 100 * locking compatibility. 101 */ 102 struct ocfs2_cluster_connection { 103 char cc_name[GROUP_NAME_MAX + 1]; 104 int cc_namelen; 105 char cc_cluster_name[CLUSTER_NAME_MAX + 1]; 106 int cc_cluster_name_len; 107 struct ocfs2_protocol_version cc_version; 108 struct ocfs2_locking_protocol *cc_proto; 109 void (*cc_recovery_handler)(int node_num, void *recovery_data); 110 void *cc_recovery_data; 111 void *cc_lockspace; 112 void *cc_private; 113 }; 114 115 /* 116 * Each cluster stack implements the stack operations structure. Not used 117 * in the ocfs2 code, the stackglue code translates generic cluster calls 118 * into stack operations. 119 */ 120 struct ocfs2_stack_operations { 121 /* 122 * The fs code calls ocfs2_cluster_connect() to attach a new 123 * filesystem to the cluster stack. The ->connect() op is passed 124 * an ocfs2_cluster_connection with the name and recovery field 125 * filled in. 126 * 127 * The stack must set up any notification mechanisms and create 128 * the filesystem lockspace in the DLM. The lockspace should be 129 * stored on cc_lockspace. Any other information can be stored on 130 * cc_private. 131 * 132 * ->connect() must not return until it is guaranteed that 133 * 134 * - Node down notifications for the filesystem will be received 135 * and passed to conn->cc_recovery_handler(). 136 * - Locking requests for the filesystem will be processed. 137 */ 138 int (*connect)(struct ocfs2_cluster_connection *conn); 139 140 /* 141 * The fs code calls ocfs2_cluster_disconnect() when a filesystem 142 * no longer needs cluster services. All DLM locks have been 143 * dropped, and recovery notification is being ignored by the 144 * fs code. The stack must disengage from the DLM and discontinue 145 * recovery notification. 146 * 147 * Once ->disconnect() has returned, the connection structure will 148 * be freed. Thus, a stack must not return from ->disconnect() 149 * until it will no longer reference the conn pointer. 150 * 151 * Once this call returns, the stack glue will be dropping this 152 * connection's reference on the module. 153 */ 154 int (*disconnect)(struct ocfs2_cluster_connection *conn); 155 156 /* 157 * ->this_node() returns the cluster's unique identifier for the 158 * local node. 159 */ 160 int (*this_node)(struct ocfs2_cluster_connection *conn, 161 unsigned int *node); 162 163 /* 164 * Call the underlying dlm lock function. The ->dlm_lock() 165 * callback should convert the flags and mode as appropriate. 166 * 167 * ast and bast functions are not part of the call because the 168 * stack will likely want to wrap ast and bast calls before passing 169 * them to stack->sp_proto. There is no astarg. The lksb will 170 * be passed back to the ast and bast functions. The caller can 171 * use this to find their object. 172 */ 173 int (*dlm_lock)(struct ocfs2_cluster_connection *conn, 174 int mode, 175 struct ocfs2_dlm_lksb *lksb, 176 u32 flags, 177 void *name, 178 unsigned int namelen); 179 180 /* 181 * Call the underlying dlm unlock function. The ->dlm_unlock() 182 * function should convert the flags as appropriate. 183 * 184 * The unlock ast is not passed, as the stack will want to wrap 185 * it before calling stack->sp_proto->lp_unlock_ast(). There is 186 * no astarg. The lksb will be passed back to the unlock ast 187 * function. The caller can use this to find their object. 188 */ 189 int (*dlm_unlock)(struct ocfs2_cluster_connection *conn, 190 struct ocfs2_dlm_lksb *lksb, 191 u32 flags); 192 193 /* 194 * Return the status of the current lock status block. The fs 195 * code should never dereference the union. The ->lock_status() 196 * callback pulls out the stack-specific lksb, converts the status 197 * to a proper errno, and returns it. 198 */ 199 int (*lock_status)(struct ocfs2_dlm_lksb *lksb); 200 201 /* 202 * Return non-zero if the LVB is valid. 203 */ 204 int (*lvb_valid)(struct ocfs2_dlm_lksb *lksb); 205 206 /* 207 * Pull the lvb pointer off of the stack-specific lksb. 208 */ 209 void *(*lock_lvb)(struct ocfs2_dlm_lksb *lksb); 210 211 /* 212 * Cluster-aware posix locks 213 * 214 * This is NULL for stacks which do not support posix locks. 215 */ 216 int (*plock)(struct ocfs2_cluster_connection *conn, 217 u64 ino, 218 struct file *file, 219 int cmd, 220 struct file_lock *fl); 221 222 /* 223 * This is an optoinal debugging hook. If provided, the 224 * stack can dump debugging information about this lock. 225 */ 226 void (*dump_lksb)(struct ocfs2_dlm_lksb *lksb); 227 }; 228 229 /* 230 * Each stack plugin must describe itself by registering a 231 * ocfs2_stack_plugin structure. This is only seen by stackglue and the 232 * stack driver. 233 */ 234 struct ocfs2_stack_plugin { 235 char *sp_name; 236 struct ocfs2_stack_operations *sp_ops; 237 struct module *sp_owner; 238 239 /* These are managed by the stackglue code. */ 240 struct list_head sp_list; 241 unsigned int sp_count; 242 struct ocfs2_protocol_version sp_max_proto; 243 }; 244 245 246 /* Used by the filesystem */ 247 int ocfs2_cluster_connect(const char *stack_name, 248 const char *cluster_name, 249 int cluster_name_len, 250 const char *group, 251 int grouplen, 252 struct ocfs2_locking_protocol *lproto, 253 void (*recovery_handler)(int node_num, 254 void *recovery_data), 255 void *recovery_data, 256 struct ocfs2_cluster_connection **conn); 257 /* 258 * Used by callers that don't store their stack name. They must ensure 259 * all nodes have the same stack. 260 */ 261 int ocfs2_cluster_connect_agnostic(const char *group, 262 int grouplen, 263 struct ocfs2_locking_protocol *lproto, 264 void (*recovery_handler)(int node_num, 265 void *recovery_data), 266 void *recovery_data, 267 struct ocfs2_cluster_connection **conn); 268 int ocfs2_cluster_disconnect(struct ocfs2_cluster_connection *conn, 269 int hangup_pending); 270 void ocfs2_cluster_hangup(const char *group, int grouplen); 271 int ocfs2_cluster_this_node(struct ocfs2_cluster_connection *conn, 272 unsigned int *node); 273 274 struct ocfs2_lock_res; 275 int ocfs2_dlm_lock(struct ocfs2_cluster_connection *conn, 276 int mode, 277 struct ocfs2_dlm_lksb *lksb, 278 u32 flags, 279 void *name, 280 unsigned int namelen); 281 int ocfs2_dlm_unlock(struct ocfs2_cluster_connection *conn, 282 struct ocfs2_dlm_lksb *lksb, 283 u32 flags); 284 285 int ocfs2_dlm_lock_status(struct ocfs2_dlm_lksb *lksb); 286 int ocfs2_dlm_lvb_valid(struct ocfs2_dlm_lksb *lksb); 287 void *ocfs2_dlm_lvb(struct ocfs2_dlm_lksb *lksb); 288 void ocfs2_dlm_dump_lksb(struct ocfs2_dlm_lksb *lksb); 289 290 int ocfs2_stack_supports_plocks(void); 291 int ocfs2_plock(struct ocfs2_cluster_connection *conn, u64 ino, 292 struct file *file, int cmd, struct file_lock *fl); 293 294 void ocfs2_stack_glue_set_max_proto_version(struct ocfs2_protocol_version *max_proto); 295 296 297 /* Used by stack plugins */ 298 int ocfs2_stack_glue_register(struct ocfs2_stack_plugin *plugin); 299 void ocfs2_stack_glue_unregister(struct ocfs2_stack_plugin *plugin); 300 301 /* In ocfs2_downconvert_lock(), we need to know which stack we are using */ 302 int ocfs2_is_o2cb_active(void); 303 304 extern struct kset *ocfs2_kset; 305 306 #endif /* STACKGLUE_H */ 307