1. 主要数据结

1. ocfs2_stack_plugin

struct ocfs2_stack_plugin {char *sp_name;struct ocfs2_stack_operations *sp_ops;struct module *sp_owner;/* These are managed by the stackglue code. */struct list_head sp_list;unsigned int sp_count;struct ocfs2_protocol_version sp_max_proto;
};

每个stack plugin，即o2cb或pacemaker，必须实例化一个该结构体。

2. ocfs2_stack_operations

/** Each cluster stack implements the stack operations structure.  Not used* in the ocfs2 code, the stackglue code translates generic cluster calls* into stack operations.*/
struct ocfs2_stack_operations {/** The fs code calls ocfs2_cluster_connect() to attach a new* filesystem to the cluster stack.  The ->connect() op is passed* an ocfs2_cluster_connection with the name and recovery field* filled in.** The stack must set up any notification mechanisms and create* the filesystem lockspace in the DLM.  The lockspace should be* stored on cc_lockspace.  Any other information can be stored on* cc_private.** ->connect() must not return until it is guaranteed that**  - Node down notifications for the filesystem will be received*    and passed to conn->cc_recovery_handler().*  - Locking requests for the filesystem will be processed.*/int (*connect)(struct ocfs2_cluster_connection *conn);/** The fs code calls ocfs2_cluster_disconnect() when a filesystem* no longer needs cluster services.  All DLM locks have been* dropped, and recovery notification is being ignored by the* fs code.  The stack must disengage from the DLM and discontinue* recovery notification.** Once ->disconnect() has returned, the connection structure will* be freed.  Thus, a stack must not return from ->disconnect()* until it will no longer reference the conn pointer.** Once this call returns, the stack glue will be dropping this* connection's reference on the module.*/int (*disconnect)(struct ocfs2_cluster_connection *conn);/** ->this_node() returns the cluster's unique identifier for the* local node.*/int (*this_node)(struct ocfs2_cluster_connection *conn,unsigned int *node);/** Call the underlying dlm lock function.  The ->dlm_lock()* callback should convert the flags and mode as appropriate.** ast and bast functions are not part of the call because the* stack will likely want to wrap ast and bast calls before passing* them to stack->sp_proto.  There is no astarg.  The lksb will* be passed back to the ast and bast functions.  The caller can* use this to find their object.*/int (*dlm_lock)(struct ocfs2_cluster_connection *conn,int mode,struct ocfs2_dlm_lksb *lksb,u32 flags,void *name,unsigned int namelen);
/** Call the underlying dlm unlock function.  The ->dlm_unlock()* function should convert the flags as appropriate.** The unlock ast is not passed, as the stack will want to wrap* it before calling stack->sp_proto->lp_unlock_ast().  There is* no astarg.  The lksb will be passed back to the unlock ast* function.  The caller can use this to find their object.*/int (*dlm_unlock)(struct ocfs2_cluster_connection *conn,struct ocfs2_dlm_lksb *lksb,u32 flags);/** Return the status of the current lock status block.  The fs* code should never dereference the union.  The ->lock_status()* callback pulls out the stack-specific lksb, converts the status* to a proper errno, and returns it.*/int (*lock_status)(struct ocfs2_dlm_lksb *lksb);/** Return non-zero if the LVB is valid.*/int (*lvb_valid)(struct ocfs2_dlm_lksb *lksb);/** Pull the lvb pointer off of the stack-specific lksb.*/void *(*lock_lvb)(struct ocfs2_dlm_lksb *lksb);/** Cluster-aware posix locks** This is NULL for stacks which do not support posix locks.*/int (*plock)(struct ocfs2_cluster_connection *conn,u64 ino,struct file *file,int cmd,struct file_lock *fl);/** This is an optoinal debugging hook.  If provided, the* stack can dump debugging information about this lock.*/void (*dump_lksb)(struct ocfs2_dlm_lksb *lksb);
};

和ocfs2_stack_plugin一样，stack plugin必须实例化一个栈操作集。该结构体是对通用操作的抽象，与ocfs2 代码无关。

3. ocfs2_cluster_connection

/** A cluster connection.  Mostly opaque to ocfs2, the connection holds* state for the underlying stack.  ocfs2 does use cc_version to determine* locking compatibility.*/
struct ocfs2_cluster_connection {char cc_name[GROUP_NAME_MAX + 1];int cc_namelen;char cc_cluster_name[CLUSTER_NAME_MAX + 1];int cc_cluster_name_len;struct ocfs2_protocol_version cc_version;struct ocfs2_locking_protocol *cc_proto;void (*cc_recovery_handler)(int node_num, void *recovery_data);void *cc_recovery_data;void *cc_lockspace;void *cc_private;
};

4. ocfs2_locking_protocol

/** The ocfs2_locking_protocol defines the handlers called on ocfs2's behalf.*/
struct ocfs2_locking_protocol {struct ocfs2_protocol_version lp_max_version;void (*lp_lock_ast)(struct ocfs2_dlm_lksb *lksb);void (*lp_blocking_ast)(struct ocfs2_dlm_lksb *lksb, int level);void (*lp_unlock_ast)(struct ocfs2_dlm_lksb *lksb, int error);
};

5. ocfs2_dlm_lksb

/** A union of all lock status structures.  We define it here so that the* size of the union is known.  Lock status structures are embedded in* ocfs2 inodes.*/
struct ocfs2_cluster_connection;
struct ocfs2_dlm_lksb {union {struct dlm_lockstatus lksb_o2dlm;struct dlm_lksb lksb_fsdlm;struct fsdlm_lksb_plus_lvb padding;};struct ocfs2_cluster_connection *lksb_conn;
};

二. 函数

1. ocfs2_cluster_connect

/* Used by the filesystem */
int ocfs2_cluster_connect(const char *stack_name,const char *cluster_name,int cluster_name_len,const char *group,int grouplen,struct ocfs2_locking_protocol *lproto,void (*recovery_handler)(int node_num,void *recovery_data),void *recovery_data,struct ocfs2_cluster_connection **conn);

struct ocfs2_super 包含 了struct ocfs2_cluster_connection *cconn。其被初始化的调用流程如：

ocfs2_fill_super --> ocfs2_mount_volume -->  ocfs2_dlm_init --> ocfs2_cluster_connect代码片段如下。

3009         /* for now, uuid == domain */
3010         status = ocfs2_cluster_connect(osb->osb_cluster_stack,
3011                                        osb->osb_cluster_name,
3012                                        strlen(osb->osb_cluster_name),
3013                                        osb->uuid_str,
3014                                        strlen(osb->uuid_str),
3015                                        &lproto, ocfs2_do_node_down, osb,
3016                                        &conn);

类似的函数有ocfs2_cluster_connect_agnostic，agnostic翻译过来是不可知论的，这里是指调用者未指定cluster stack的名字。

相反的函数自然是ocfs2_cluster_disconnect了。

2.  ocfs2_cluster_hangup

/*                                 * Hangup is a required post-umount.  ocfs2-tools software expects the* filesystem to call "ocfs2_hb_ctl" during unmount.  This happens* regardless of whether the DLM got started, so we can't do it* in ocfs2_cluster_disconnect().  The ocfs2_leave_group() function does* the actual work.          */
void ocfs2_cluster_hangup(const char *group, int grouplen)
{BUG_ON(group == NULL);BUG_ON(group[grouplen] != '\0');ocfs2_leave_group(group);/* cluster_disconnect() was called with hangup_pending==1 */ocfs2_stack_driver_put();
}
EXPORT_SYMBOL_GPL(ocfs2_cluster_hangup);

3. ocfs2_cluster_this_node

int ocfs2_cluster_this_node(struct ocfs2_cluster_connection *conn,unsigned int *node)
{return active_stack->sp_ops->this_node(conn, node);
}
EXPORT_SYMBOL_GPL(ocfs2_cluster_this_node);

4. ocfs2_dlm_lock

235 /*
236  * The ocfs2_dlm_lock() and ocfs2_dlm_unlock() functions take no argument
237  * for the ast and bast functions.  They will pass the lksb to the ast
238  * and bast.  The caller can wrap the lksb with their own structure to
239  * get more information.
240  */
241 int ocfs2_dlm_lock(struct ocfs2_cluster_connection *conn,
242                    int mode,
243                    struct ocfs2_dlm_lksb *lksb,
244                    u32 flags,
245                    void *name,
246                    unsigned int namelen)
247 {
248         if (!lksb->lksb_conn)
249                 lksb->lksb_conn = conn;
250         else
251                 BUG_ON(lksb->lksb_conn != conn);
252         return active_stack->sp_ops->dlm_lock(conn, mode, lksb, flags,
253                                               name, namelen);
254 }
255 EXPORT_SYMBOL_GPL(ocfs2_dlm_lock);

类似的封装函数还有：

257 int ocfs2_dlm_unlock(struct ocfs2_cluster_connection *conn,
258                      struct ocfs2_dlm_lksb *lksb,
259                      u32 flags)
260 {
261         BUG_ON(lksb->lksb_conn == NULL);
262
263         return active_stack->sp_ops->dlm_unlock(conn, lksb, flags);
264 }
265 EXPORT_SYMBOL_GPL(ocfs2_dlm_unlock);
266
267 int ocfs2_dlm_lock_status(struct ocfs2_dlm_lksb *lksb)
268 {
269         return active_stack->sp_ops->lock_status(lksb);
270 }
271 EXPORT_SYMBOL_GPL(ocfs2_dlm_lock_status);
272
273 int ocfs2_dlm_lvb_valid(struct ocfs2_dlm_lksb *lksb)
274 {
275         return active_stack->sp_ops->lvb_valid(lksb);
276 }
277 EXPORT_SYMBOL_GPL(ocfs2_dlm_lvb_valid);
278
279 void *ocfs2_dlm_lvb(struct ocfs2_dlm_lksb *lksb)
280 {
281         return active_stack->sp_ops->lock_lvb(lksb);
282 }
283 EXPORT_SYMBOL_GPL(ocfs2_dlm_lvb);
284
285 void ocfs2_dlm_dump_lksb(struct ocfs2_dlm_lksb *lksb)
286 {
287         active_stack->sp_ops->dump_lksb(lksb);
288 }
289 EXPORT_SYMBOL_GPL(ocfs2_dlm_dump_lksb);