ocfs2 update
PATCH 1/1 ocfs2 update
Here's one last patch for the merge window. It allows the cluster stack to negotiate a common protocol version with mounting nodes, as opposed to requiring an exact match as we do today. The patch itself requires a protocol change, so it'd be nice to see this upstream with all the other network changes we did for 2.6.25. I held this patch back from my initial pull request so that we could a bit more testing on it.
--Mark
Please pull from 'upstream-linus' branch ofgit://git.kernel.org/pub/scm/linux/kernel/git/mfasheh/ocfs2.git upstream-linus
to receive the following updates:
fs/ocfs2/cluster/tcp_internal.h | 11 ++- fs/ocfs2/dlm/dlmapi.h | 7 +- fs/ocfs2/dlm/dlmcommon.h | 24 +++++- fs/ocfs2/dlm/dlmdomain.c | 195 +++++++++++++++++++++++++++++++++----- fs/ocfs2/dlm/dlmfs.c | 15 +++- fs/ocfs2/dlm/userdlm.c | 5 +- fs/ocfs2/dlm/userdlm.h | 3 +- fs/ocfs2/dlmglue.c | 29 ++++++- fs/ocfs2/dlmglue.h | 1 + fs/ocfs2/ocfs2.h | 1 + fs/ocfs2/ocfs2_lockingver.h | 30 ++++++ fs/ocfs2/super.c | 1 + 12 files changed, 288 insertions(+), 34 deletions(-) create mode 100644 fs/ocfs2/ocfs2_lockingver.h
Joel Becker (1):
ocfs2: Negotiate locking protocol versions.
fs/ocfs2/cluster/tcp_internal.h +10 -1
@@ -38,6 +38,15 @@* locking semantics of the file system using the protocol. It should * be somewhere else, I'm sure, but right now it isn't. * +* With version 11, we separate out the filesystem locking portion. The +* filesystem now has a major.minor version it negotiates. Version 11 +* introduces this negotiation to the o2dlm protocol, and as such the +* version here in tcp_internal.h should not need to be bumped for +* filesystem locking changes. +* +* New in version 11 +* - Negotiation of filesystem locking in the dlm join. +* * New in version 10: * - Meta/data locks combined *
@@ -66,7 +75,7 @@* - full 64 bit i_size in the metadata lock lvbs * - introduction of "rw" lock and pushing meta/data locking down */ -#define O2NET_PROTOCOL_VERSION 10ULL +#define O2NET_PROTOCOL_VERSION 11ULLstruct o2net_handshake {__be64 protocol_version;__be64 connector_id;
fs/ocfs2/dlm/dlmapi.h +6 -1
@@ -193,7 +193,12 @@ enum dlm_status dlmunlock(struct dlm_ctxt *dlm, dlm_astunlockfunc_t *unlockast, void *data); -struct dlm_ctxt *dlm_register_domain (const char *domain,u32 key); +struct dlm_protocol_version { +u8 pv_major; +u8 pv_minor; +}; +struct dlm_ctxt *dlm_register_domain (const char *domain,u32 key, +struct dlm_protocol_version *fs_proto);void dlm_unregister_domain (struct dlm_ctxt *dlm);
fs/ocfs2/dlm/dlmcommon.h +23 -1
@@ -142,6 +142,12 @@ struct dlm_ctxtspinlock_t work_lock;struct list_head dlm_domain_handlers;struct list_head dlm_eviction_callbacks; + +/* The filesystem specifies this at domain registration. We +* cache it here to know what to tell other nodes. */ +struct dlm_protocol_version fs_locking_proto; +/* This is the inter-dlm communication version */ +struct dlm_protocol_version dlm_locking_proto; };static inline struct hlist_head *dlm_lockres_hash (struct dlm_ctxt *dlm,unsigned i)
@@ -589,10 +595,24 @@ struct dlm_proxy_ast#define DLM_PROXY_AST_MAX_LEN (sizeof(struct dlm_proxy_ast)+DLM_LVB_LEN)#define DLM_MOD_KEY (0x666c6172) -enum dlm_query_join_response { +enum dlm_query_join_response_code {JOIN_DISALLOW =0 ,JOIN_OK ,JOIN_OK_NO_MAP , +JOIN_PROTOCOL_MISMATCH , +}; + +union dlm_query_join_response { +u32 intval; +struct { +u8 code;/* Response code. dlm_minor and fs_minor +are only valid if this is JOIN_OK */ +u8 dlm_minor;/* The minor version of the protocol the +dlm is speaking. */ +u8 fs_minor;/* The minor version of the protocol the +filesystem is speaking. */ +u8 reserved; + } packet; };struct dlm_lock_request
@@ -633,6 +653,8 @@ struct dlm_query_join_requestu8 node_idx;u8 pad1[2 ];u8 name_len; +struct dlm_protocol_version dlm_proto; +struct dlm_protocol_version fs_proto;u8 domain[O2NM_MAX_NAME_LEN ];u8 node_map[BITS_TO_BYTES (O2NM_MAX_NODES )]; };
fs/ocfs2/dlm/dlmdomain.c +169 -26
327 lines not on this page · raw message
fs/ocfs2/dlm/dlmfs.c +14 -1
@@ -60,6 +60,8 @@#define MLOG_MASK_PREFIX ML_DLMFS#include "cluster/masklog.h" +#include "ocfs2_lockingver.h" +static const struct super_operations dlmfs_ops;static const struct file_operations dlmfs_file_operations;static const struct inode_operations dlmfs_dir_inode_operations;
@@ -70,6 +72,16 @@ static struct kmem_cache *dlmfs_inode_cache;struct workqueue_struct *user_dlm_worker;/* +* This is the userdlmfs locking protocol version. +* +* See fs/ocfs2/dlmglue.c for more details on locking versions. +*/ +static const struct dlm_protocol_version user_locking_protocol = { + .pv_major =OCFS2_LOCKING_PROTOCOL_MAJOR , + .pv_minor =OCFS2_LOCKING_PROTOCOL_MINOR , +}; + +/* * decodes a set of open flags into a valid lock level and a set of flags. * returns < 0 if we have invalid flags * flags which mean something to us:
@@ -416,6 +428,7 @@ static int dlmfs_mkdir(struct inode * dir,struct qstr *domain = &dentry->d_name;struct dlmfs_inode_private *ip;struct dlm_ctxt *dlm; +struct dlm_protocol_version proto = user_locking_protocol;mlog (0 ,"mkdir %.*s\n" , domain->len, domain->name);
@@ -435,7 +448,7 @@ static int dlmfs_mkdir(struct inode * dir, ip =DLMFS_I (inode); - dlm =user_dlm_register_context (domain); + dlm =user_dlm_register_context (domain, &proto);if (IS_ERR (dlm)) { status =PTR_ERR (dlm); mlog(ML_ERROR, "Error %d could not register domain \"%.*s\"\n",
fs/ocfs2/dlm/userdlm.c +3 -2
@@ -645,7 +645,8 @@ bail:return status; } -struct dlm_ctxt *user_dlm_register_context (struct qstr *name) +struct dlm_ctxt *user_dlm_register_context (struct qstr *name, +struct dlm_protocol_version *proto) {struct dlm_ctxt *dlm;u32 dlm_key;
@@ -661,7 +662,7 @@ struct dlm_ctxt *user_dlm_register_context(struct qstr *name)snprintf (domain, name->len +1 ,"%.*s" , name->len, name->name); - dlm =dlm_register_domain (domain, dlm_key); + dlm =dlm_register_domain (domain, dlm_key, proto);if (IS_ERR (dlm))mlog_errno (PTR_ERR (dlm));
fs/ocfs2/dlm/userdlm.h +2 -1
@@ -83,7 +83,8 @@ void user_dlm_write_lvb(struct inode *inode,void user_dlm_read_lvb (struct inode *inode,char *val,unsigned int len); -struct dlm_ctxt *user_dlm_register_context (struct qstr *name); +struct dlm_ctxt *user_dlm_register_context (struct qstr *name, +struct dlm_protocol_version *proto);void user_dlm_unregister_context (struct dlm_ctxt *dlm);struct dlmfs_inode_private {
fs/ocfs2/dlmglue.c +28 -1
@@ -43,6 +43,7 @@#include <cluster/masklog.h> #include "ocfs2.h" +#include "ocfs2_lockingver.h" #include "alloc.h" #include "dcache.h"
@@ -258,6 +259,31 @@ static struct ocfs2_lock_res_ops ocfs2_flock_lops = { .flags = 0, }; +/* +* This is the filesystem locking protocol version. +* +* Whenever the filesystem does new things with locks (adds or removes a +* lock, orders them differently, does different things underneath a lock), +* the version must be changed. The protocol is negotiated when joining +* the dlm domain. A node may join the domain if its major version is +* identical to all other nodes and its minor version is greater than +* or equal to all other nodes. When its minor version is greater than +* the other nodes, it will run at the minor version specified by the +* other nodes. +* +* If a locking change is made that will not be compatible with older +* versions, the major number must be increased and the minor version set +* to zero. If a change merely adds a behavior that can be disabled when +* speaking to older versions, the minor version must be increased. If a +* change adds a fully backwards compatible change (eg, LVB changes that +* are just ignored by older versions), the version does not need to be +* updated. +*/ +const struct dlm_protocol_version ocfs2_locking_protocol = { + .pv_major =OCFS2_LOCKING_PROTOCOL_MAJOR , + .pv_minor =OCFS2_LOCKING_PROTOCOL_MINOR , +}; +static inline int ocfs2_is_inode_lock (struct ocfs2_lock_res *lockres) { return lockres->l_type == OCFS2_LOCK_TYPE_META ||
@@ -2506,7 +2532,8 @@ int ocfs2_dlm_init(struct ocfs2_super *osb) dlm_key =crc32_le (0 , osb->uuid_str,strlen (osb->uuid_str));/* for now, uuid == domain */ - dlm =dlm_register_domain (osb->uuid_str, dlm_key); + dlm =dlm_register_domain (osb->uuid_str, dlm_key, + &osb->osb_locking_proto);if (IS_ERR (dlm)) { status =PTR_ERR (dlm);mlog_errno (status);
fs/ocfs2/dlmglue.h +1 -0
@@ -116,4 +116,5 @@ void ocfs2_wake_downconvert_thread(struct ocfs2_super *osb);struct ocfs2_dlm_debug *ocfs2_new_dlm_debug (void );void ocfs2_put_dlm_debug (struct ocfs2_dlm_debug *dlm_debug); +extern const struct dlm_protocol_version ocfs2_locking_protocol;#endif /* DLMGLUE_H */
fs/ocfs2/ocfs2.h +1 -0
@@ -251,6 +251,7 @@ struct ocfs2_superstruct ocfs2_lock_res osb_rename_lockres;struct dlm_eviction_cb osb_eviction_cb;struct ocfs2_dlm_debug *osb_dlm_debug; +struct dlm_protocol_version osb_locking_proto;struct dentry *osb_debug_root;
fs/ocfs2/ocfs2_lockingver.h new file +30 -0
@@ -0,0 +1,30 @@ +/* -*- mode: c; c-basic-offset: 8; -*- +* vim: noexpandtab sw=8 ts=8 sts=0: +* +* ocfs2_lockingver.h +* +* Defines OCFS2 Locking version values. +* +* Copyright (C) 2008 Oracle. All rights reserved. +* +* This program is free software; you can redistribute it and/or +* modify it under the terms of the GNU General Public +* License, version 2, as published by the Free Software Foundation. +* +* This program is distributed in the hope that it will be useful, +* but WITHOUT ANY WARRANTY; without even the implied warranty of +* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +* General Public License for more details. +*/ + +#ifndef OCFS2_LOCKINGVER_H +#define OCFS2_LOCKINGVER_H + +/* +* The protocol version for ocfs2 cluster locking. See dlmglue.c for +* more details. +*/ +#define OCFS2_LOCKING_PROTOCOL_MAJOR 1 +#define OCFS2_LOCKING_PROTOCOL_MINOR 0 + +#endif /* OCFS2_LOCKINGVER_H */
fs/ocfs2/super.c +1 -0
@@ -1355,6 +1355,7 @@ static int ocfs2_initialize_super(struct super_block *sb, sb->s_fs_info = osb; sb->s_op = &ocfs2_sops; sb->s_export_op = &ocfs2_export_ops; + osb->osb_locking_proto = ocfs2_locking_protocol; sb->s_time_gran =1 ; sb->s_flags |=MS_NOATIME ;/* this is needed to support O_LARGEFILE */
Quoted 14 lines · On Thu, 7 Feb 2008 12:09:44 -0800 Mark Fasheh <[email protected]> wrote:
/*
- *dlm_register_domain: one-time setup per "domain"
+ * Compare a requested locking protocol version against the current one.
+ *
+ * If the major numbers are different, they are incompatible.
+ * If the current minor is greater than the request, they are incompatible.
+ * If the current minor is less than or equal to the request, they are
+ * compatible, and the requester should run at the current minor version.
+ */fs/ocfs2/dlm/dlmdomain.c +5
-0+static int dlm_protocol_compare (struct dlm_protocol_version *existing, +struct dlm_protocol_version *request) +{ +if (existing->pv_major != request->pv_major) +return 1 ;
fs/ocfs2/dlm/dlmdomain.c leave: · line 1570
Quoted 10 lines
fs/ocfs2/dlm/dlmdomain.c +10
-0+ +if (existing->pv_minor > request->pv_minor) +return 1 ; + +if (existing->pv_minor < request->pv_minor) + request->pv_minor = existing->pv_minor; + +return 0 ; +} +
It's somewhat obnoxious that what appears to be a straightforward compare-two-things-and-return-result function will actually modify one of the things which it is allegedly comparing.
Please integrate checkpatch into your processes - this one had a few little glitches.
Quoted 23 lines · Andrew Morton
Quoted 20 lines · On Thu, 7 Feb 2008 12:09:44 -0800 Mark Fasheh <[email protected]> wrote:
/*
- *dlm_register_domain: one-time setup per "domain"
+ * Compare a requested locking protocol version against the current one.
+ *
+ * If the major numbers are different, they are incompatible.
+ * If the current minor is greater than the request, they are incompatible.
+ * If the current minor is less than or equal to the request, they are
+ * compatible, and the requester should run at the current minor version.
+ */fs/ocfs2/dlm/dlmdomain.c +11
-0+static int dlm_protocol_compare (struct dlm_protocol_version *existing, +struct dlm_protocol_version *request) +{ +if (existing->pv_major != request->pv_major) +return 1 ; + +if (existing->pv_minor > request->pv_minor) +return 1 ; + +if (existing->pv_minor < request->pv_minor) + request->pv_minor = existing->pv_minor;
Quoted 8 lines
fs/ocfs2/dlm/dlmdomain.c leave: · line 1570
Quoted 4 lines
fs/ocfs2/dlm/dlmdomain.c +4
-0+ +return 0 ; +} +It's somewhat obnoxious that what appears to be a straightforward compare-two-things-and-return-result function will actually modify one of the things which it is allegedly comparing.
Yeah, a better name would probably help with readability. Joel, how about dlm_protocol_compare_and_set()?
Quoted 2 lines
Please integrate checkpatch into your processes - this one had a few little glitches.
FWIW - I've run all patches through checkpatch.pl since your last review. This one went through a couple cycles of checkpatch actually :) There's three warnings that I get:
ERROR: "foo * bar" should be "foo *bar"
#70: FILE: fs/ocfs2/dlm/dlmapi.h:200:
+struct dlm_ctxt * dlm_register_domain(const char *domain, u32 key,
WARNING: line over 80 characters
#269: FILE: fs/ocfs2/dlm/dlmdomain.c:813:
+
#&dlm->fs_locking_proto,
WARNING: line over 80 characters
#270: FILE: fs/ocfs2/dlm/dlmdomain.c:814:
+
#&query->fs_proto)) {
total: 1 errors, 2 warnings, 569 lines checked
The "foo * bar" one is from existing code which got moved, and I felt that leaving them unmodified was cleaner from a patch-reading perspective.
The over 80 characters warnings were ignored as the code seemed more readable as-is.
I guess a lot of this can be subjective though, so I can be super strict if you really feel it's necessary.
Thanks,
--Mark
--
Mark Fasheh
Principal Software Developer, Oracle
[email protected]
Quoted 11 lines · Mark Fasheh
Quoted 9 lines · Andrew Morton
Review
Quoted 2 lines · On Thu, 7 Feb 2008 12:09:44 -0800 Mark Fasheh <[email protected]> wrote:
(quoted diff) +2
-0+static int dlm_protocol_compare(struct dlm_protocol_version *existing, + struct dlm_protocol_version *request)It's somewhat obnoxious that what appears to be a straightforward compare-two-things-and-return-result function will actually modify one of the things which it is allegedly comparing.
Quoted 2 lines
Yeah, a better name would probably help with readability. Joel, how about
dlm_protocol_compare_and_set()?
Even better is to move the update outside the function. What do
we think of the following?
From d667a08d73cd6659219d21cc57f67882f46e42d1 Mon Sep 17 00:00:00 2001
From: Joel Becker <[email protected]>
Date: Thu, 7 Feb 2008 14:25:11 -0800
Subject: [PATCH] ocfs2: Clean up locking protocol negotiation.
The comparison functions for protocol negotiation (introduced in commit d24fbcda0c4988322949df3d759f1cfb32b32953) were confusing. Separate out the comparison and value update parts.
--- fs/ocfs2/dlm/dlmdomain.c | 102 ++++++++++++++++++++++------------------------ 1 files changed, 49 insertions(+), 53 deletions(-)
fs/ocfs2/dlm/dlmdomain.c +49 -53
@@ -144,8 +144,6 @@ static int dlm_cancel_join_handler(struct o2net_msg *msg, u32 len, void *data, void **ret_data);static int dlm_exit_domain_handler (struct o2net_msg *msg,u32 len,void *data,void **ret_data); -static int dlm_protocol_compare (struct dlm_protocol_version *existing, -struct dlm_protocol_version *request);static void dlm_unregister_domain_handlers (struct dlm_ctxt *dlm);
@@ -681,36 +679,48 @@ void dlm_unregister_domain(struct dlm_ctxt *dlm) }EXPORT_SYMBOL_GPL (dlm_unregister_domain); +/* +* Compare a requested locking protocol version against the current one. +* +* If the major numbers are different, they are incompatible. +* If the current minor is greater than the request, they are incompatible. +* If the current minor is less than or equal to the request, they are +* compatible, and the requester should run at the current minor version. +*/ +static int dlm_protocol_compatible (struct dlm_protocol_version *existing, +struct dlm_protocol_version *request) +{ +if (existing->pv_major != request->pv_major) +return 0 ; + +if (existing->pv_minor > request->pv_minor) +return 0 ; + +return 1 ; +} +static int dlm_query_join_proto_check (char *proto_type,int node,struct dlm_protocol_version *ours,struct dlm_protocol_version *request) { -int rc; -struct dlm_protocol_version proto = *request; +int compatible =dlm_protocol_compatible (ours, request); -if (!dlm_protocol_compare (ours, &proto)) { +if (compatible)mlog (0 ,"node %u wanted to join with %s locking protocol " "%u.%u, we respond with %u.%u\n" , node, proto_type, - request->pv_major, - request->pv_minor, - proto.pv_major, proto.pv_minor); - request->pv_minor = proto.pv_minor; - rc =0 ; - }else { + request->pv_major, request->pv_minor, + ours->pv_major, ours->pv_minor); +else mlog (ML_NOTICE ,"Node %u wanted to join with %s locking " "protocol %u.%u, but we have %u.%u, disallowing\n" , node, proto_type, - request->pv_major, - request->pv_minor, - ours->pv_major, - ours->pv_minor); - rc =1 ; - } + request->pv_major, request->pv_minor, + ours->pv_major, ours->pv_minor); -return rc; +return compatible; } static int dlm_query_join_handler(struct o2net_msg *msg, u32 len, void *data,
@@ -806,21 +816,23 @@ static int dlm_query_join_handler(struct o2net_msg *msg, u32 len, void *data,/* Make sure we speak compatible locking protocols. */ if (dlm_query_join_proto_check ("DLM" , bit, &dlm->dlm_locking_proto, - &query->dlm_proto)) { - response.packet.code = -JOIN_PROTOCOL_MISMATCH ; - }else if (dlm_query_join_proto_check ("fs" , bit, - &dlm->fs_locking_proto, - &query->fs_proto)) { - response.packet.code = -JOIN_PROTOCOL_MISMATCH ; - }else { + &query->dlm_proto) && +dlm_query_join_proto_check ("fs" , bit, + &dlm->fs_locking_proto, + &query->fs_proto)) { +/* +* We're compatible, return our +* minor number +*/ response.packet.dlm_minor = - query->dlm_proto.pv_minor; + dlm->dlm_locking_proto.pv_minor; response.packet.fs_minor = - query->fs_proto.pv_minor; + dlm->fs_locking_proto.pv_minor; response.packet.code =JOIN_OK ;__dlm_set_joining_node (dlm, query->node_idx); + }else { + response.packet.code = +JOIN_PROTOCOL_MISMATCH ; } }
@@ -1546,29 +1558,6 @@ leave: }/* -* Compare a requested locking protocol version against the current one. -* -* If the major numbers are different, they are incompatible. -* If the current minor is greater than the request, they are incompatible. -* If the current minor is less than or equal to the request, they are -* compatible, and the requester should run at the current minor version. -*/ -static int dlm_protocol_compare (struct dlm_protocol_version *existing, -struct dlm_protocol_version *request) -{ -if (existing->pv_major != request->pv_major) -return 1 ; - -if (existing->pv_minor > request->pv_minor) -return 1 ; - -if (existing->pv_minor < request->pv_minor) - request->pv_minor = existing->pv_minor; - -return 0 ; -} - -/* * dlm_register_domain: one-time setup per "domain". * * The filesystem passes in the requested locking version via proto.
@@ -1620,7 +1609,14 @@ retry: goto retry; } -if (dlm_protocol_compare (&dlm->fs_locking_proto, fs_proto)) { +if (dlm_protocol_compatible (&dlm->fs_locking_proto, fs_proto)) { +/* +* We're compatible, and we run at the minor +* number negotiated +*/ + fs_proto->pv_minor = + dlm->fs_locking_proto.pv_minor; + }else {mlog (ML_ERROR ,"Requested locking protocol version is not " "compatible with already registered domain "
Signature · 15 lines
1.5.2.2 -- "Gone to plant a weeping willow On the bank's green edge it will roll, roll, roll. Sing a lulaby beside the waters. Lovers come and go, the river roll, roll, rolls." Joel Becker Principal Software Developer Oracle E-mail: [email protected] Phone: (650) 506-8127
Quoted 4 lines · On Thu, 7 Feb 2008 13:37:15 -0800 Mark Fasheh <[email protected]> wrote:
Quoted 2 lines
Please integrate checkpatch into your processes - this one had a few little glitches.
FWIW - I've run all patches through checkpatch.pl since your last review.
cool, thanks.
Quoted 17 lines
This one went through a couple cycles of checkpatch actually :) There's three warnings that I get:
ERROR: "foo * bar" should be "foo *bar"
#70: FILE:fs/ocfs2/dlm/dlmapi.h:200:
+structdlm_ctxt* dlm_register_domain(const char *domain, u32 key,WARNING: line over 80 characters
#269: FILE:fs/ocfs2/dlm/dlmdomain.c:813:
+
#&dlm->fs_locking_proto,WARNING: line over 80 characters
#270: FILE:fs/ocfs2/dlm/dlmdomain.c:814:
+
#&query->fs_proto)) {
Quoted 5 lines
total: 1 errors, 2 warnings, 569 lines checked
The "foo * bar" one is from existing code which got moved, and I felt that leaving them unmodified was cleaner from a patch-reading perspective.
I tend to clean those things up as we go, because it's a free patch.
otoh I see that dlm style is presently space-after-asterisk so there's not a lot of point in fixing just one of them.
Quoted 2 lines
The over 80 characters warnings were ignored as the code seemed more readable as-is.
yes, I tend to ignore those warnings unless the mess is really gratuitous or if the surrounding code has obviously made some effort to avoid the problem.
Quoted 2 lines
I guess a lot of this can be subjective though, so I can be super strict if you really feel it's necessary.
No, you shouldn't view checkpatch as a things-i-must-do. It is a things-i-might-have-missed tool. If you _meant_ things to be that way then fine, ignore it.