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 * Once this call returns, the stack glue will be dropping this 138 * connection's reference on the module. 139 */ 140 int (*disconnect)(struct ocfs2_cluster_connection *conn); 141 142 /* 143 * ->this_node() returns the cluster's unique identifier for the 144 * local node. 145 */ 146 int (*this_node)(unsigned int *node); 147 148 /* 149 * Call the underlying dlm lock function. The ->dlm_lock() 150 * callback should convert the flags and mode as appropriate. 151 * 152 * ast and bast functions are not part of the call because the 153 * stack will likely want to wrap ast and bast calls before passing 154 * them to stack->sp_proto. 155 */ 156 int (*dlm_lock)(struct ocfs2_cluster_connection *conn, 157 int mode, 158 union ocfs2_dlm_lksb *lksb, 159 u32 flags, 160 void *name, 161 unsigned int namelen, 162 void *astarg); 163 164 /* 165 * Call the underlying dlm unlock function. The ->dlm_unlock() 166 * function should convert the flags as appropriate. 167 * 168 * The unlock ast is not passed, as the stack will want to wrap 169 * it before calling stack->sp_proto->lp_unlock_ast(). 170 */ 171 int (*dlm_unlock)(struct ocfs2_cluster_connection *conn, 172 union ocfs2_dlm_lksb *lksb, 173 u32 flags, 174 void *astarg); 175 176 /* 177 * Return the status of the current lock status block. The fs 178 * code should never dereference the union. The ->lock_status() 179 * callback pulls out the stack-specific lksb, converts the status 180 * to a proper errno, and returns it. 181 */ 182 int (*lock_status)(union ocfs2_dlm_lksb *lksb); 183 184 /* 185 * Pull the lvb pointer off of the stack-specific lksb. 186 */ 187 void *(*lock_lvb)(union ocfs2_dlm_lksb *lksb); 188 189 /* 190 * This is an optoinal debugging hook. If provided, the 191 * stack can dump debugging information about this lock. 192 */ 193 void (*dump_lksb)(union ocfs2_dlm_lksb *lksb); 194 }; 195 196 /* 197 * Each stack plugin must describe itself by registering a 198 * ocfs2_stack_plugin structure. This is only seen by stackglue and the 199 * stack driver. 200 */ 201 struct ocfs2_stack_plugin { 202 char *sp_name; 203 struct ocfs2_stack_operations *sp_ops; 204 struct module *sp_owner; 205 206 /* These are managed by the stackglue code. */ 207 struct list_head sp_list; 208 unsigned int sp_count; 209 struct ocfs2_locking_protocol *sp_proto; 210 }; 211 212 213 /* Used by the filesystem */ 214 int ocfs2_cluster_connect(const char *stack_name, 215 const char *group, 216 int grouplen, 217 void (*recovery_handler)(int node_num, 218 void *recovery_data), 219 void *recovery_data, 220 struct ocfs2_cluster_connection **conn); 221 int ocfs2_cluster_disconnect(struct ocfs2_cluster_connection *conn, 222 int hangup_pending); 223 void ocfs2_cluster_hangup(const char *group, int grouplen); 224 int ocfs2_cluster_this_node(unsigned int *node); 225 226 struct ocfs2_lock_res; 227 int ocfs2_dlm_lock(struct ocfs2_cluster_connection *conn, 228 int mode, 229 union ocfs2_dlm_lksb *lksb, 230 u32 flags, 231 void *name, 232 unsigned int namelen, 233 struct ocfs2_lock_res *astarg); 234 int ocfs2_dlm_unlock(struct ocfs2_cluster_connection *conn, 235 union ocfs2_dlm_lksb *lksb, 236 u32 flags, 237 struct ocfs2_lock_res *astarg); 238 239 int ocfs2_dlm_lock_status(union ocfs2_dlm_lksb *lksb); 240 void *ocfs2_dlm_lvb(union ocfs2_dlm_lksb *lksb); 241 void ocfs2_dlm_dump_lksb(union ocfs2_dlm_lksb *lksb); 242 243 void ocfs2_stack_glue_set_locking_protocol(struct ocfs2_locking_protocol *proto); 244 245 246 /* Used by stack plugins */ 247 int ocfs2_stack_glue_register(struct ocfs2_stack_plugin *plugin); 248 void ocfs2_stack_glue_unregister(struct ocfs2_stack_plugin *plugin); 249 250 #endif /* STACKGLUE_H */ 251