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